TEXT

app/myapp/angular.json

@@ -13,6 +13,7 @@
         "build": {
           "builder": "@angular-devkit/build-angular:browser",
           "options": {
+            
             "outputPath": "www",
             "index": "src/index.html",
             "main": "src/main.ts",

app/myapp/src/app/tab1/AIwenbenbuquan/page-training-plan/page-training-plan.component.html

@@ -0,0 +1,109 @@
+<ion-header>
+  <ion-toolbar color="primary">
+    <ion-title>个性化训练计划生成器</ion-title>
+    <ion-buttons slot="end">
+      <ion-button (click)="resetForm()">
+        <ion-icon name="refresh" slot="icon-only"></ion-icon>
+      </ion-button>
+    </ion-buttons>
+  </ion-toolbar>
+</ion-header>
+
+<ion-content class="ion-padding">
+  <div class="form-container">
+    <ion-list>
+      <ion-item>
+        <ion-select label="运动项目" [(ngModel)]="selectedSport" interface="action-sheet">
+          <ion-select-option *ngFor="let sport of sports" [value]="sport">{{sport}}</ion-select-option>
+        </ion-select>
+      </ion-item>
+
+      <ion-item>
+        <ion-input type="number" label="年龄" [(ngModel)]="age" min="10" max="100"></ion-input>
+      </ion-item>
+
+      <ion-item>
+        <ion-input type="number" label="身高(cm)" [(ngModel)]="height" min="100" max="250"></ion-input>
+      </ion-item>
+
+      <ion-item>
+        <ion-input type="number" label="体重(kg)" [(ngModel)]="weight" min="30" max="200"></ion-input>
+      </ion-item>
+
+      <ion-item>
+        <ion-select label="运动水平" [(ngModel)]="selectedLevel" interface="action-sheet">
+          <ion-select-option *ngFor="let level of skillLevels" [value]="level">{{level}}</ion-select-option>
+        </ion-select>
+      </ion-item>
+
+      <ion-item>
+        <ion-textarea 
+          label="训练目标" 
+          [(ngModel)]="trainingGoal" 
+          placeholder="例如：提高投篮命中率、增强耐力、学习基本技巧等"
+          rows="3"
+          autoGrow="true"
+        ></ion-textarea>
+      </ion-item>
+    </ion-list>
+
+    <ion-button 
+      expand="block" 
+      (click)="generatePlan()"
+      [disabled]="isLoading"
+    >
+      <ion-spinner *ngIf="isLoading" name="lines"></ion-spinner>
+      <span *ngIf="!isLoading">生成训练计划</span>
+    </ion-button>
+  </div>
+
+  <ion-card *ngIf="planGenerated">
+    <ion-card-header>
+      <ion-card-title>
+        <ion-icon name="barbell-outline"></ion-icon>
+        您的{{selectedSport}}训练计划
+      </ion-card-title>
+    </ion-card-header>
+    <ion-card-content>
+      <div class="ai-content">
+        @if(!planGenerated){
+          <div [innerHTML]="aiContent"></div>
+        }
+        @if(planGenerated){
+          <fm-markdown-preview class="content-style" [content]="aiContent"></fm-markdown-preview>
+        }
+      </div> <!-- 删除了 keepHtml 管道 -->
+    </ion-card-content>
+  </ion-card>
+
+  <div *ngIf="!planGenerated && !isLoading" class="tips-section">
+    <ion-card>
+      <ion-card-header>
+        <ion-card-title>
+          <ion-icon name="information-circle-outline"></ion-icon>
+          使用提示
+        </ion-card-title>
+      </ion-card-header>
+      <ion-card-content>
+        <ion-list lines="none">
+          <ion-item>
+            <ion-icon name="checkmark-circle" slot="start" color="success"></ion-icon>
+            <ion-label>请选择您要训练的运动项目</ion-label>
+          </ion-item>
+          <ion-item>
+            <ion-icon name="checkmark-circle" slot="start" color="success"></ion-icon>
+            <ion-label>准确填写您的身体数据</ion-label>
+          </ion-item>
+          <ion-item>
+            <ion-icon name="checkmark-circle" slot="start" color="success"></ion-icon>
+            <ion-label>如实评估您的运动水平</ion-label>
+          </ion-item>
+          <ion-item>
+            <ion-icon name="checkmark-circle" slot="start" color="success"></ion-icon>
+            <ion-label>详细描述您的训练目标</ion-label>
+          </ion-item>
+        </ion-list>
+      </ion-card-content>
+    </ion-card>
+  </div>
+</ion-content>

app/myapp/src/app/tab1/AIwenbenbuquan/page-training-plan/page-training-plan.component.scss

@@ -0,0 +1,47 @@
+:host {
+  display: block;
+  height: 100%;
+}
+
+.form-container {
+  max-width: 800px;
+  margin: 0 auto;
+}
+
+.ai-content {
+  white-space: pre-line;
+  line-height: 1.6;
+  
+  h1, h2, h3 {
+    margin-top: 1.5rem;
+    margin-bottom: 0.5rem;
+    color: var(--ion-color-primary);
+  }
+  
+  ul, ol {
+    padding-left: 1.5rem;
+  }
+  
+  li {
+    margin-bottom: 0.5rem;
+  }
+}
+
+.tips-section {
+  margin-top: 2rem;
+  max-width: 800px;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+ion-card {
+  margin-bottom: 1.5rem;
+  border-radius: 12px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+}
+
+ion-textarea {
+  --background: var(--ion-color-light);
+  border-radius: 8px;
+  margin-top: 8px;
+}

app/myapp/src/app/tab1/AIwenbenbuquan/page-training-plan/page-training-plan.component.spec.ts

@@ -0,0 +1,22 @@
+import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+
+import { PageTrainingPlanComponent } from './page-training-plan.component';
+
+describe('PageTrainingPlanComponent', () => {
+  let component: PageTrainingPlanComponent;
+  let fixture: ComponentFixture<PageTrainingPlanComponent>;
+
+  beforeEach(waitForAsync(() => {
+    TestBed.configureTestingModule({
+      imports: [PageTrainingPlanComponent],
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(PageTrainingPlanComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  }));
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

app/myapp/src/app/tab1/AIwenbenbuquan/page-training-plan/page-training-plan.component.ts

@@ -0,0 +1,108 @@
+import { Component, OnInit } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { IonicModule } from '@ionic/angular';
+import { FmodeChatCompletion,MarkdownPreviewModule } from 'fmode-ng';
+
+
+@Component({
+  selector: 'app-page-training-plan',
+  templateUrl: './page-training-plan.component.html',
+  styleUrls: ['./page-training-plan.component.scss'],
+  standalone: true,
+  imports: [IonicModule, CommonModule, FormsModule,MarkdownPreviewModule]
+})
+export class PageTrainingPlanComponent implements OnInit {
+  sports = ['篮球', '足球', '排球', '羽毛球', '网球', '乒乓球'];
+  skillLevels = ['入门', '新手', '老手', '高手', '专业'];
+  
+  selectedSport: string = '篮球';
+  age: number = 25;
+  height: number = 175;
+  weight: number = 70;
+  selectedLevel: string = '新手';
+  trainingGoal: string = '';
+  
+  aiContent: string = '请填写您的信息并点击"生成计划"按钮，我将为您创建个性化的训练方案。';
+  isLoading: boolean = false;
+  planGenerated: boolean = false;
+
+  constructor() {}
+
+  ngOnInit() {
+    // 可以在这里添加初始化逻辑
+  }
+
+  generatePlan() {
+    if (!this.trainingGoal.trim()) {
+      this.aiContent = '请先填写您的训练目标';
+      return;
+    }
+
+    this.isLoading = true;
+    this.planGenerated = false;
+    this.aiContent = '正在为您生成训练计划...';
+
+    const now = new Date();
+    const timeParams = `当前时间：${now.toLocaleString()}`;
+    
+    const prompt = `你是一名专业的运动训练师，请根据以下信息为用户制定一份详细的${this.selectedSport}训练计划：
+    
+    用户信息：
+    - 年龄: ${this.age}岁
+    - 身高: ${this.height}cm
+    - 体重: ${this.weight}kg
+    - 运动水平: ${this.selectedLevel}
+    - 训练目标: ${this.trainingGoal}
+    
+    请生成一份为期4周的训练计划，包含每周的训练安排、具体的训练内容、强度建议和注意事项。要求计划科学合理，适合用户的当前水平，并有助于达成其训练目标。
+    
+    输出格式：
+    # ${this.selectedSport}个性化训练计划（4周）
+    
+    ## 用户概况
+    [简要总结用户信息]
+    
+    ## 训练目标
+    [明确训练目标]
+    
+    ## 每周训练安排
+    [按周详细说明]
+    
+    ## 注意事项
+    [列出重要注意事项]`;
+
+    const completion = new FmodeChatCompletion([
+      { role: "system", content: timeParams },
+      { role: "user", content: prompt }
+    ]);
+
+    completion.sendCompletion().subscribe({
+      next: (message: any) => {
+        if (message.content) {
+          this.aiContent = message.content;
+        }
+        if (message.complete) {
+          this.isLoading = false;
+          this.planGenerated = true;
+        }
+      },
+      error: (err: Error) => {
+        this.aiContent = '生成计划时出错，请稍后再试。';
+        this.isLoading = false;
+        console.error(err);
+      }
+    });
+  }
+
+  resetForm() {
+    this.selectedSport = '篮球';
+    this.age = 25;
+    this.height = 175;
+    this.weight = 70;
+    this.selectedLevel = '新手';
+    this.trainingGoal = '';
+    this.aiContent = '请填写您的信息并点击"生成计划"按钮，我将为您创建个性化的训练方案。';
+    this.planGenerated = false;
+  }
+}

app/myapp/src/app/tab1/tab1.page.html

@@ -18,14 +18,17 @@
   
       <!-- 完整战术按钮组 -->
       <div class="button-grid">
-        <div class="tactics-btn">
-            <div class="tactics-icon" style="background-image:url('//iconfont.alicdn.com/t/font_1234567_wtzczz.css')"></div>
-            <div class="btn-text">
-                <div class="btn-title">文韬智策</div>
-                <div class="btn-subtitle">战略规划中枢</div>
+        <ion-button (click)="goTraining()">
+            <div class="tactics-btn">
+             <div class="tactics-icon" style="background-image:url('//iconfont.alicdn.com/t/font_1234567_wtzczz.css')"></div>
+             <div class="btn-text">
+                 <div class="btn-title">六韬智策</div>
+                 <div class="btn-subtitle">战略规划中枢</div>
             </div>
         </div>
-        <div class="tactics-btn">
+        </ion-button>
+        
+        <!-- <div class="tactics-btn">
             <div class="tactics-icon" style="background-image:url('//iconfont.alicdn.com/t/font_1234567_xyzabc.css')"></div>
             <div class="btn-text">
                 <div class="btn-title">武韬战枢</div>
@@ -59,7 +62,7 @@
                 <div class="btn-title">犬韬训典</div>
                 <div class="btn-subtitle">动作基准火纹</div>
             </div>
-        </div>
+        </div> -->
     </div>
   
       <!-- 广告区域 -->

app/myapp/src/app/tab1/tab1.page.scss

@@ -74,9 +74,12 @@ body {
 }
 
 .button-grid {
-    display: grid;
-    grid-template-columns: repeat(3, 1fr);
-    gap: 15px;
+    width: 100%; /* 占满整行 */
+    margin: 0 auto; /* 左右居中 */
+    aspect-ratio: 2 / 1; /* 宽度是高度的2倍 */
+    // display: grid;
+    // grid-template-columns: repeat(3, 1fr);
+    // gap: 15px;
 }
 
 .tactics-btn {

app/myapp/src/app/tab1/tab1.page.ts

@@ -233,5 +233,7 @@ export class Tab1Page {
     })
     return
   }
-
+  goTraining(){
+    this.navCtrl.navigateRoot(['tabs','AIwenbenbuquan','training'])
+  }
 }

app/myapp/src/app/tabs/tabs-routing.module.ts

@@ -1,6 +1,7 @@
 import { NgModule } from '@angular/core';
 import { RouterModule, Routes } from '@angular/router';
 import { TabsPage } from './tabs.page';
+import { PageTrainingPlanComponent } from '../tab1/AIwenbenbuquan/page-training-plan/page-training-plan.component'; // 导入组件
 
 const routes: Routes = [
   {
@@ -23,6 +24,10 @@ const routes: Routes = [
         path: '',
         redirectTo: '/tabs/tab1',
         pathMatch: 'full'
+      },
+      {
+        path: 'AIwenbenbuquan/training',
+        component: PageTrainingPlanComponent // 直接使用组件
       }
     ]
   },
@@ -36,4 +41,4 @@ const routes: Routes = [
 @NgModule({
   imports: [RouterModule.forChild(routes)],
 })
-export class TabsPageRoutingModule {}
+export class TabsPageRoutingModule {}

app/myapp/tsconfig.app.json

@@ -3,7 +3,9 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "outDir": "./out-tsc/app",
-    "types": []
+    "types": [],
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true
   },
   "files": [
     "src/main.ts",

node_modules/.bin/markdown-it

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../markdown-it/bin/markdown-it.mjs" "$@"
+else 
+  exec node  "$basedir/../markdown-it/bin/markdown-it.mjs" "$@"
+fi

node_modules/.bin/markdown-it.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\markdown-it\bin\markdown-it.mjs" %*

node_modules/.bin/markdown-it.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../markdown-it/bin/markdown-it.mjs" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../markdown-it/bin/markdown-it.mjs" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../markdown-it/bin/markdown-it.mjs" $args
+  } else {
+    & "node$exe"  "$basedir/../markdown-it/bin/markdown-it.mjs" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/mustache

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../mustache/bin/mustache" "$@"
+else 
+  exec node  "$basedir/../mustache/bin/mustache" "$@"
+fi

node_modules/.bin/mustache.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\mustache\bin\mustache" %*

node_modules/.bin/mustache.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../mustache/bin/mustache" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../mustache/bin/mustache" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../mustache/bin/mustache" $args
+  } else {
+    & "node$exe"  "$basedir/../mustache/bin/mustache" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/qrcode

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../qrcode/bin/qrcode" "$@"
+else 
+  exec node  "$basedir/../qrcode/bin/qrcode" "$@"
+fi

node_modules/.bin/qrcode.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\qrcode\bin\qrcode" %*

node_modules/.bin/qrcode.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../qrcode/bin/qrcode" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../qrcode/bin/qrcode" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../qrcode/bin/qrcode" $args
+  } else {
+    & "node$exe"  "$basedir/../qrcode/bin/qrcode" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/semver

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../semver/bin/semver.js" "$@"
+else 
+  exec node  "$basedir/../semver/bin/semver.js" "$@"
+fi

node_modules/.bin/semver.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\semver\bin\semver.js" %*

node_modules/.bin/semver.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../semver/bin/semver.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../semver/bin/semver.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../semver/bin/semver.js" $args
+  } else {
+    & "node$exe"  "$basedir/../semver/bin/semver.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/sre

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../speech-rule-engine/bin/sre" "$@"
+else 
+  exec node  "$basedir/../speech-rule-engine/bin/sre" "$@"
+fi

node_modules/.bin/sre.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\speech-rule-engine\bin\sre" %*

node_modules/.bin/sre.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../speech-rule-engine/bin/sre" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../speech-rule-engine/bin/sre" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../speech-rule-engine/bin/sre" $args
+  } else {
+    & "node$exe"  "$basedir/../speech-rule-engine/bin/sre" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/stencil

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../@stencil/core/bin/stencil" "$@"
+else 
+  exec node  "$basedir/../@stencil/core/bin/stencil" "$@"
+fi

node_modules/.bin/stencil.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\@stencil\core\bin\stencil" %*

node_modules/.bin/stencil.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../@stencil/core/bin/stencil" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../@stencil/core/bin/stencil" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../@stencil/core/bin/stencil" $args
+  } else {
+    & "node$exe"  "$basedir/../@stencil/core/bin/stencil" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/tsc

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsc" "$@"
+else 
+  exec node  "$basedir/../typescript/bin/tsc" "$@"
+fi

node_modules/.bin/tsc.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\typescript\bin\tsc" %*

node_modules/.bin/tsc.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../typescript/bin/tsc" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../typescript/bin/tsc" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../typescript/bin/tsc" $args
+  } else {
+    & "node$exe"  "$basedir/../typescript/bin/tsc" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/tsserver

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsserver" "$@"
+else 
+  exec node  "$basedir/../typescript/bin/tsserver" "$@"
+fi

node_modules/.bin/tsserver.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\typescript\bin\tsserver" %*

node_modules/.bin/tsserver.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../typescript/bin/tsserver" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../typescript/bin/tsserver" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../typescript/bin/tsserver" $args
+  } else {
+    & "node$exe"  "$basedir/../typescript/bin/tsserver" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/uuid

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../uuid/dist/bin/uuid" "$@"
+else 
+  exec node  "$basedir/../uuid/dist/bin/uuid" "$@"
+fi

node_modules/.bin/uuid.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\uuid\dist\bin\uuid" %*

node_modules/.bin/uuid.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../uuid/dist/bin/uuid" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../uuid/dist/bin/uuid" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../uuid/dist/bin/uuid" $args
+  } else {
+    & "node$exe"  "$basedir/../uuid/dist/bin/uuid" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.package-lock.json

@@ -0,0 +1,1934 @@
+{
+  "name": "AGI",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@amap/amap-jsapi-loader": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/@amap/amap-jsapi-loader/-/amap-jsapi-loader-1.0.1.tgz",
+      "integrity": "sha512-nPyLKt7Ow/ThHLkSvn2etQlUzqxmTVgK7bIgwdBRTg2HK5668oN7xVxkaiRe3YZEzGzfV2XgH5Jmu2T73ljejw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@angular/animations": {
+      "version": "19.2.13",
+      "resolved": "https://registry.npmmirror.com/@angular/animations/-/animations-19.2.13.tgz",
+      "integrity": "sha512-x9LYcSndY9BdwuRxTx0gXvlLrvJyzjnWoaIoVLrAZWZbKfQh2+HK4XkclbzNvn8RMeoBpZZatcC3ZBC1TffjtA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "tslib": "^2.3.0"
+      },
+      "engines": {
+        "node": "^18.19.1 || ^20.11.1 || >=22.0.0"
+      },
+      "peerDependencies": {
+        "@angular/common": "19.2.13",
+        "@angular/core": "19.2.13"
+      }
+    },
+    "node_modules/@angular/cdk": {
+      "version": "19.2.17",
+      "resolved": "https://registry.npmmirror.com/@angular/cdk/-/cdk-19.2.17.tgz",
+      "integrity": "sha512-3jG33S+5+kqymCRwQlcSEWlY5rYwkKxe0onln+NXxT0/kteR02vWvv1+Li4/QqSr5JvsGHEhAFsZaR9QtOzbdA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "parse5": "^7.1.2",
+        "tslib": "^2.3.0"
+      },
+      "peerDependencies": {
+        "@angular/common": "^19.0.0 || ^20.0.0",
+        "@angular/core": "^19.0.0 || ^20.0.0",
+        "rxjs": "^6.5.3 || ^7.4.0"
+      }
+    },
+    "node_modules/@angular/common": {
+      "version": "19.2.13",
+      "resolved": "https://registry.npmmirror.com/@angular/common/-/common-19.2.13.tgz",
+      "integrity": "sha512-k7I4bLH+bgI02VL81MaL0NcZPfVl153KAiARwk+ZlkmQjMnWlmsAHQ6054SWoNEXwP855ATR6YYDVqJh8TZaqw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "tslib": "^2.3.0"
+      },
+      "engines": {
+        "node": "^18.19.1 || ^20.11.1 || >=22.0.0"
+      },
+      "peerDependencies": {
+        "@angular/core": "19.2.13",
+        "rxjs": "^6.5.3 || ^7.4.0"
+      }
+    },
+    "node_modules/@angular/core": {
+      "version": "19.2.13",
+      "resolved": "https://registry.npmmirror.com/@angular/core/-/core-19.2.13.tgz",
+      "integrity": "sha512-HpzDI3TSQzVV2mmQ8KwH0JSLNlYNemNrEo3L3hcqqYwTzqFgAK4y1Q2Xym3yiRSLTenYhW5D4CQqOHUQ26HxwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.3.0"
+      },
+      "engines": {
+        "node": "^18.19.1 || ^20.11.1 || >=22.0.0"
+      },
+      "peerDependencies": {
+        "rxjs": "^6.5.3 || ^7.4.0",
+        "zone.js": "~0.15.0"
+      }
+    },
+    "node_modules/@angular/forms": {
+      "version": "19.2.13",
+      "resolved": "https://registry.npmmirror.com/@angular/forms/-/forms-19.2.13.tgz",
+      "integrity": "sha512-g46KQFrBJhmknczlGEYvWVsPhk7ZI8WOuWkzWEl81Lf3ojEVA/OF8w4VwKZL7wOMKRxOUhuYq6tNPm8tBjtryw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "tslib": "^2.3.0"
+      },
+      "engines": {
+        "node": "^18.19.1 || ^20.11.1 || >=22.0.0"
+      },
+      "peerDependencies": {
+        "@angular/common": "19.2.13",
+        "@angular/core": "19.2.13",
+        "@angular/platform-browser": "19.2.13",
+        "rxjs": "^6.5.3 || ^7.4.0"
+      }
+    },
+    "node_modules/@angular/material": {
+      "version": "19.2.17",
+      "resolved": "https://registry.npmmirror.com/@angular/material/-/material-19.2.17.tgz",
+      "integrity": "sha512-IyA+KP+uUj3r9loqGJrj7qAiEBckj7EVIdV0jlYwqWIUyKWeJ3R88GmLPMH2BgtBU3R/WkS2blXDI0yvRhKfww==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "tslib": "^2.3.0"
+      },
+      "peerDependencies": {
+        "@angular/cdk": "19.2.17",
+        "@angular/common": "^19.0.0 || ^20.0.0",
+        "@angular/core": "^19.0.0 || ^20.0.0",
+        "@angular/forms": "^19.0.0 || ^20.0.0",
+        "@angular/platform-browser": "^19.0.0 || ^20.0.0",
+        "rxjs": "^6.5.3 || ^7.4.0"
+      }
+    },
+    "node_modules/@angular/platform-browser": {
+      "version": "19.2.13",
+      "resolved": "https://registry.npmmirror.com/@angular/platform-browser/-/platform-browser-19.2.13.tgz",
+      "integrity": "sha512-YeuRfGbo8qFepoAUoubk/1079wOown5Qgr9eAhgCXxoXb2rt87xbJF3YCSSim38SP3kK1rJQqP+Sr8n7ef+n5Q==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "tslib": "^2.3.0"
+      },
+      "engines": {
+        "node": "^18.19.1 || ^20.11.1 || >=22.0.0"
+      },
+      "peerDependencies": {
+        "@angular/animations": "19.2.13",
+        "@angular/common": "19.2.13",
+        "@angular/core": "19.2.13"
+      },
+      "peerDependenciesMeta": {
+        "@angular/animations": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@angular/router": {
+      "version": "19.2.13",
+      "resolved": "https://registry.npmmirror.com/@angular/router/-/router-19.2.13.tgz",
+      "integrity": "sha512-BZObWQtGkDv2WHyLVRRecGbLwalbI8kOXKaVgN5dqP4z/t5bpzYXZixPO9e0E1Ff0+m4tQalhTc84j8X7XZuTw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "tslib": "^2.3.0"
+      },
+      "engines": {
+        "node": "^18.19.1 || ^20.11.1 || >=22.0.0"
+      },
+      "peerDependencies": {
+        "@angular/common": "19.2.13",
+        "@angular/core": "19.2.13",
+        "@angular/platform-browser": "19.2.13",
+        "rxjs": "^6.5.3 || ^7.4.0"
+      }
+    },
+    "node_modules/@ant-design/colors": {
+      "version": "7.2.1",
+      "resolved": "https://registry.npmmirror.com/@ant-design/colors/-/colors-7.2.1.tgz",
+      "integrity": "sha512-lCHDcEzieu4GA3n8ELeZ5VQ8pKQAWcGGLRTQ50aQM2iqPpq2evTxER84jfdPvsPAtEcZ7m44NI45edFMo8oOYQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@ant-design/fast-color": "^2.0.6"
+      }
+    },
+    "node_modules/@ant-design/fast-color": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmmirror.com/@ant-design/fast-color/-/fast-color-2.0.6.tgz",
+      "integrity": "sha512-y2217gk4NqL35giHl72o6Zzqji9O7vHh9YmhUVkPtAOpoTCH4uWxo/pr4VE8t0+ChEPs0qo4eJRC5Q1eXWo3vA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/runtime": "^7.24.7"
+      },
+      "engines": {
+        "node": ">=8.x"
+      }
+    },
+    "node_modules/@ant-design/icons-angular": {
+      "version": "19.0.0",
+      "resolved": "https://registry.npmmirror.com/@ant-design/icons-angular/-/icons-angular-19.0.0.tgz",
+      "integrity": "sha512-bBWFA1cTZwLAFTgpozkeNIHX1nXyZuiUaRzTcAfFEt85eW1X3ypMcBfS/XEVVVzkdTw5Td+E1vwzgfuUlKiYSA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@ant-design/colors": "^7.0.0",
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "@angular/common": "^19.0.0",
+        "@angular/core": "^19.0.0",
+        "@angular/platform-browser": "^19.0.0",
+        "rxjs": "^6.5.3 || ^7.4.0"
+      }
+    },
+    "node_modules/@awesome-cordova-plugins/core": {
+      "version": "6.16.0",
+      "resolved": "https://registry.npmmirror.com/@awesome-cordova-plugins/core/-/core-6.16.0.tgz",
+      "integrity": "sha512-ep+nkDY6CyFBfqS/HS03PE+MZWiQoJWb/nLMwfj2ndC14UgZeVO3ecmEFknYjJOBf04emTbs7hbLewFrVkazmg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/cordova": "latest"
+      },
+      "peerDependencies": {
+        "rxjs": "^5.5.0 || ^6.5.0 || ^7.3.0"
+      }
+    },
+    "node_modules/@awesome-cordova-plugins/diagnostic": {
+      "version": "6.16.0",
+      "resolved": "https://registry.npmmirror.com/@awesome-cordova-plugins/diagnostic/-/diagnostic-6.16.0.tgz",
+      "integrity": "sha512-tVlK0xXpDSaC3xq2N1VJEntDMX1r3yNd+RR8LmsAUu1KVoQXpvcRzKlHyOIwNMRz8XH+7a3Lom0wTozoD/Ipeg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/cordova": "latest"
+      },
+      "peerDependencies": {
+        "@awesome-cordova-plugins/core": "^6.0.1",
+        "rxjs": "^5.5.0 || ^6.5.0 || ^7.3.0"
+      }
+    },
+    "node_modules/@awesome-cordova-plugins/media-capture": {
+      "version": "6.16.0",
+      "resolved": "https://registry.npmmirror.com/@awesome-cordova-plugins/media-capture/-/media-capture-6.16.0.tgz",
+      "integrity": "sha512-fuIOofoqJ44WzCsJeo7FGrpqDK73WDIPRqLOWwuML7ompqZO0Yv0C3tTYBWxSqH1Vfk+OYfZhqtwOW56u4yWIw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/cordova": "latest"
+      },
+      "peerDependencies": {
+        "@awesome-cordova-plugins/core": "^6.0.1",
+        "rxjs": "^5.5.0 || ^6.5.0 || ^7.3.0"
+      }
+    },
+    "node_modules/@babel/runtime": {
+      "version": "7.27.3",
+      "resolved": "https://registry.npmmirror.com/@babel/runtime/-/runtime-7.27.3.tgz",
+      "integrity": "sha512-7EYtGezsdiDMyY80+65EzwiGmcJqpmcZCojSXaRgdrBaGtWTgDZKq69cPIVped6MkIM78cTQ2GOiEYjwOlG4xw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/runtime-corejs2": {
+      "version": "7.27.3",
+      "resolved": "https://registry.npmmirror.com/@babel/runtime-corejs2/-/runtime-corejs2-7.27.3.tgz",
+      "integrity": "sha512-O/FH8C4cUj89SCRor2udo+E9W+xG+lvv1VA/DWjLr6aJrs70dAc+b/MaptsjVz3fd4LTBMSRR/+Wo5jNfYYD7g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "core-js": "^2.6.12"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/runtime-corejs3": {
+      "version": "7.24.7",
+      "resolved": "https://registry.npmmirror.com/@babel/runtime-corejs3/-/runtime-corejs3-7.24.7.tgz",
+      "integrity": "sha512-eytSX6JLBY6PVAeQa2bFlDx/7Mmln/gaEpsit5a3WEvjGfiIytEsgAwuIXCPM0xvw0v0cJn3ilq0/TvXrW0kgA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "core-js-pure": "^3.30.2",
+        "regenerator-runtime": "^0.14.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babylonjs/core": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmmirror.com/@babylonjs/core/-/core-7.2.3.tgz",
+      "integrity": "sha512-SzNVgkSJi4hErSL3+VmAJIoUrN4pc2BNVHU3DZqR7ZxzwmhhaF+c5tO9CQIi4loS3PdvjEdSUY5K5dnPhxQXfQ==",
+      "license": "Apache-2.0",
+      "peer": true
+    },
+    "node_modules/@babylonjs/loaders": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmmirror.com/@babylonjs/loaders/-/loaders-7.2.3.tgz",
+      "integrity": "sha512-K5FNhcimQzwstgUHSH5da6VVSeyeEDbIgRrlEW7faqXyEbELECxwo+Y5wPvLTAtwyG5VMgqx8eDwJCH9mPogNQ==",
+      "license": "Apache-2.0",
+      "peer": true,
+      "peerDependencies": {
+        "@babylonjs/core": "^7.0.0",
+        "babylonjs-gltf2interface": "^7.0.0"
+      }
+    },
+    "node_modules/@capacitor/camera": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmmirror.com/@capacitor/camera/-/camera-7.0.1.tgz",
+      "integrity": "sha512-gDUFsYlhMra5VVOa4iJV6+MQRhp3VXpTLQY4JDATj7UvoZ8Hv4DG8qplPL9ufUFNoR3QbDDnf8+gbQOsKdkDjg==",
+      "license": "MIT",
+      "peer": true,
+      "peerDependencies": {
+        "@capacitor/core": ">=7.0.0"
+      }
+    },
+    "node_modules/@capacitor/clipboard": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmmirror.com/@capacitor/clipboard/-/clipboard-7.0.1.tgz",
+      "integrity": "sha512-n4XEHma7apLOYvyeaR9S5u3uGzDYG7WeQxmtZlwP01HneIzMnusVgw4Im6I+pMBcoUN9TfVdf6eqKph97B1bAw==",
+      "license": "MIT",
+      "peer": true,
+      "peerDependencies": {
+        "@capacitor/core": ">=7.0.0"
+      }
+    },
+    "node_modules/@capacitor/core": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmmirror.com/@capacitor/core/-/core-7.2.0.tgz",
+      "integrity": "sha512-2zCnA6RJeZ9ec4470o8QMZEQTWpekw9FNoqm5TLc10jeCrhvHVI8MPgxdZVc3mOdFlyieYu4AS1fNxSqbS57Pw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "tslib": "^2.1.0"
+      }
+    },
+    "node_modules/@capacitor/filesystem": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmmirror.com/@capacitor/filesystem/-/filesystem-7.1.1.tgz",
+      "integrity": "sha512-xAQvurZlfKOO7I8d98GFRymS/Dd25sw0L1weF4dKR59nXloWEeagoFv+xtaNlDfolJHo4/uKVvxsLzM0xSmiUQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@capacitor/synapse": "^1.0.1"
+      },
+      "peerDependencies": {
+        "@capacitor/core": ">=7.0.0"
+      }
+    },
+    "node_modules/@capacitor/synapse": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/@capacitor/synapse/-/synapse-1.0.2.tgz",
+      "integrity": "sha512-ynq39s4D2rhk+aVLWKfKfMCz9SHPKijL9tq8aFL5dG7ik7/+PvBHmg9cPHbqdvFEUSMmaGzL6cIjzkOruW7vGA==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/@cfworker/json-schema": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmmirror.com/@cfworker/json-schema/-/json-schema-4.1.1.tgz",
+      "integrity": "sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@ctrl/tinycolor": {
+      "version": "3.6.1",
+      "resolved": "https://registry.npmmirror.com/@ctrl/tinycolor/-/tinycolor-3.6.1.tgz",
+      "integrity": "sha512-SITSV6aIXsuVNV3f3O0f2n/cgyEDWoSqtZMYiAmcsYHydcKrOz3gUxB/iXd/Qf08+IZX4KpgNbvUdMBmWz+kcA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@ionic/angular": {
+      "version": "8.5.7",
+      "resolved": "https://registry.npmmirror.com/@ionic/angular/-/angular-8.5.7.tgz",
+      "integrity": "sha512-emXv0hEX1nzvyC25lgW4lf2JGseJF3G1DLzdDcNlZ+TKTbPwfCHRop6p3zKZtmFSAoRtdw1rsNEKX+B5YbliGA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@ionic/core": "8.5.7",
+        "ionicons": "^7.0.0",
+        "jsonc-parser": "^3.0.0",
+        "tslib": "^2.3.0"
+      },
+      "peerDependencies": {
+        "@angular/core": ">=16.0.0",
+        "@angular/forms": ">=16.0.0",
+        "@angular/router": ">=16.0.0",
+        "rxjs": ">=7.5.0",
+        "zone.js": ">=0.13.0"
+      }
+    },
+    "node_modules/@ionic/core": {
+      "version": "8.5.7",
+      "resolved": "https://registry.npmmirror.com/@ionic/core/-/core-8.5.7.tgz",
+      "integrity": "sha512-V5ZRYXD1MgAPdjfLyOejILAdTqIzpMY7/v6GSynFPPWoEpfFbGe/tNsimrYm1/D8iouigYLkJjWSeg2rpIpESA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@stencil/core": "4.20.0",
+        "ionicons": "^7.2.2",
+        "tslib": "^2.1.0"
+      }
+    },
+    "node_modules/@langchain/core": {
+      "version": "0.3.57",
+      "resolved": "https://registry.npmmirror.com/@langchain/core/-/core-0.3.57.tgz",
+      "integrity": "sha512-jz28qCTKJmi47b6jqhQ6vYRTG5jRpqhtPQjriRTB5wR8mgvzo6xKs0fG/kExS3ZvM79ytD1npBvgf8i19xOo9Q==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@cfworker/json-schema": "^4.0.2",
+        "ansi-styles": "^5.0.0",
+        "camelcase": "6",
+        "decamelize": "1.2.0",
+        "js-tiktoken": "^1.0.12",
+        "langsmith": "^0.3.29",
+        "mustache": "^4.2.0",
+        "p-queue": "^6.6.2",
+        "p-retry": "4",
+        "uuid": "^10.0.0",
+        "zod": "^3.22.4",
+        "zod-to-json-schema": "^3.22.3"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@stencil/core": {
+      "version": "4.20.0",
+      "resolved": "https://registry.npmmirror.com/@stencil/core/-/core-4.20.0.tgz",
+      "integrity": "sha512-WPrTHFngvN081RY+dJPneKQLwnOFD60OMCOQGmmSHfCW0f4ujPMzzhwWU1gcSwXPWXz5O+8cBiiCaxAbJU7kAg==",
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "stencil": "bin/stencil"
+      },
+      "engines": {
+        "node": ">=16.0.0",
+        "npm": ">=7.10.0"
+      }
+    },
+    "node_modules/@types/cordova": {
+      "version": "11.0.3",
+      "resolved": "https://registry.npmmirror.com/@types/cordova/-/cordova-11.0.3.tgz",
+      "integrity": "sha512-kyuRQ40/NWQVhqGIHq78Ehu2Bf9Mlg0LhmSmis6ZFJK7z933FRfYi8tHe/k/0fB+PGfCf95rJC6TO7dopaFvAg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/node": {
+      "version": "22.15.21",
+      "resolved": "https://registry.npmmirror.com/@types/node/-/node-22.15.21.tgz",
+      "integrity": "sha512-EV/37Td6c+MgKAbkcLG6vqZ2zEYHD7bvSrzqqs2RIhbA6w3x+Dqz8MZM3sP6kGTeLrdoOgKZe+Xja7tUB2DNkQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/parse": {
+      "version": "3.0.9",
+      "resolved": "https://registry.npmmirror.com/@types/parse/-/parse-3.0.9.tgz",
+      "integrity": "sha512-DGTHygc7krgmNAK8h42giwmAofCd9uv2++RD+zw6OmWI7AEnlTYZwEuWsx22SA2CSMQrZW8P2INHLpQbnQFUng==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/retry": {
+      "version": "0.12.0",
+      "resolved": "https://registry.npmmirror.com/@types/retry/-/retry-0.12.0.tgz",
+      "integrity": "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/spark-md5": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmmirror.com/@types/spark-md5/-/spark-md5-3.0.5.tgz",
+      "integrity": "sha512-lWf05dnD42DLVKQJZrDHtWFidcLrHuip01CtnC2/S6AMhX4t9ZlEUj4iuRlAnts0PQk7KESOqKxeGE/b6sIPGg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/uuid": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmmirror.com/@types/uuid/-/uuid-10.0.0.tgz",
+      "integrity": "sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/webrtc": {
+      "version": "0.0.37",
+      "resolved": "https://registry.npmmirror.com/@types/webrtc/-/webrtc-0.0.37.tgz",
+      "integrity": "sha512-JGAJC/ZZDhcrrmepU4sPLQLIOIAgs5oIK+Ieq90K8fdaNMhfdfqmYatJdgif1NDQtvrSlTOGJDUYHIDunuufOg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@wecom/jssdk": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmmirror.com/@wecom/jssdk/-/jssdk-2.3.1.tgz",
+      "integrity": "sha512-9XxeY/kljYZF1tKk9v0ZOR/Amz2Y8cxrmZTEBTN/Zqb6WsbpHiDPOWbvpvUBrTsiCW4w7nDnvYYi01ZsOUcUYQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@xmldom/xmldom": {
+      "version": "0.9.8",
+      "resolved": "https://registry.npmmirror.com/@xmldom/xmldom/-/xmldom-0.9.8.tgz",
+      "integrity": "sha512-p96FSY54r+WJ50FIOsCOjyj/wavs8921hG5+kVMmZgKcvIKxMXHTrjNJvRgWa/zuX3B6t2lijLNFaOyuxUH+2A==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=14.6"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmmirror.com/agent-base/-/agent-base-6.0.2.tgz",
+      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "license": "Python-2.0",
+      "peer": true
+    },
+    "node_modules/axios": {
+      "version": "0.26.1",
+      "resolved": "https://registry.npmmirror.com/axios/-/axios-0.26.1.tgz",
+      "integrity": "sha512-fPwcX4EvnSHuInCMItEhAGnaSEXRBjtzh9fOtsE6E1G6p7vl7edEeZe11QHf18+6+9gR5PbKV/sGKNaD8YaMeA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "follow-redirects": "^1.14.8"
+      }
+    },
+    "node_modules/babylonjs-gltf2interface": {
+      "version": "7.54.3",
+      "resolved": "https://registry.npmmirror.com/babylonjs-gltf2interface/-/babylonjs-gltf2interface-7.54.3.tgz",
+      "integrity": "sha512-ZAWYFyE+SOczfWT19O4e3YRkCZ5i57SiD2eK2kqc+Tow/t9X1S45xgSFNuHZff++dd5BlVIEQDSnFV+McFLSnQ==",
+      "license": "Apache-2.0",
+      "peer": true
+    },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmmirror.com/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/bent": {
+      "version": "7.3.12",
+      "resolved": "https://registry.npmmirror.com/bent/-/bent-7.3.12.tgz",
+      "integrity": "sha512-T3yrKnVGB63zRuoco/7Ybl7BwwGZR0lceoVG5XmQyMIH9s19SV5m+a8qam4if0zQuAmOQTyPTPmsQBdAorGK3w==",
+      "license": "Apache-2.0",
+      "peer": true,
+      "dependencies": {
+        "bytesish": "^0.4.1",
+        "caseless": "~0.12.0",
+        "is-stream": "^2.0.0"
+      }
+    },
+    "node_modules/blueimp-md5": {
+      "version": "2.19.0",
+      "resolved": "https://registry.npmmirror.com/blueimp-md5/-/blueimp-md5-2.19.0.tgz",
+      "integrity": "sha512-DRQrD6gJyy8FbiE4s+bDoXS9hiW3Vbx5uCdwvcCf3zLHL+Iv7LtGHLpr+GZV8rHG8tK766FGYBwRbu8pELTt+w==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/bytesish": {
+      "version": "0.4.4",
+      "resolved": "https://registry.npmmirror.com/bytesish/-/bytesish-0.4.4.tgz",
+      "integrity": "sha512-i4uu6M4zuMUiyfZN4RU2+i9+peJh//pXhd9x1oSe1LBkZ3LEbCoygu8W0bXTukU1Jme2txKuotpCZRaC3FLxcQ==",
+      "license": "(Apache-2.0 AND MIT)",
+      "peer": true
+    },
+    "node_modules/camelcase": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmmirror.com/camelcase/-/camelcase-6.3.0.tgz",
+      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/caseless": {
+      "version": "0.12.0",
+      "resolved": "https://registry.npmmirror.com/caseless/-/caseless-0.12.0.tgz",
+      "integrity": "sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==",
+      "license": "Apache-2.0",
+      "peer": true
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmmirror.com/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/chalk/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmmirror.com/cliui/-/cliui-6.0.0.tgz",
+      "integrity": "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.0",
+        "wrap-ansi": "^6.2.0"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/commander": {
+      "version": "13.1.0",
+      "resolved": "https://registry.npmmirror.com/commander/-/commander-13.1.0.tgz",
+      "integrity": "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/console-table-printer": {
+      "version": "2.13.0",
+      "resolved": "https://registry.npmmirror.com/console-table-printer/-/console-table-printer-2.13.0.tgz",
+      "integrity": "sha512-Wl1rFO1NLonYBBjrdF2SMCnfNrKr8PPooPSnQBRX3LTJsnyGjBzLcwffo8wSKuJ0kr/rgC2Ltxb3Bpb072VA9w==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "simple-wcswidth": "^1.0.1"
+      }
+    },
+    "node_modules/core-js": {
+      "version": "2.6.12",
+      "resolved": "https://registry.npmmirror.com/core-js/-/core-js-2.6.12.tgz",
+      "integrity": "sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==",
+      "deprecated": "core-js@<3.23.3 is no longer maintained and not recommended for usage due to the number of issues. Because of the V8 engine whims, feature detection in old core-js versions could cause a slowdown up to 100x even if nothing is polyfilled. Some versions have web compatibility issues. Please, upgrade your dependencies to the actual version of core-js.",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/core-js-pure": {
+      "version": "3.42.0",
+      "resolved": "https://registry.npmmirror.com/core-js-pure/-/core-js-pure-3.42.0.tgz",
+      "integrity": "sha512-007bM04u91fF4kMgwom2I5cQxAFIy8jVulgr9eozILl/SZE53QOqnW/+vviC+wQWLv+AunBG+8Q0TLoeSsSxRQ==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "peer": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/core-js"
+      }
+    },
+    "node_modules/crypto-js": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmmirror.com/crypto-js/-/crypto-js-4.2.0.tgz",
+      "integrity": "sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/date-fns": {
+      "version": "2.30.0",
+      "resolved": "https://registry.npmmirror.com/date-fns/-/date-fns-2.30.0.tgz",
+      "integrity": "sha512-fnULvOpxnC5/Vg3NCiWelDsLiUc9bRwAPs/+LfTLNvetFCtCTN+yQz15C/fs4AwX1R9K5GLtLfn8QW+dWisaAw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/runtime": "^7.21.0"
+      },
+      "engines": {
+        "node": ">=0.11"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/date-fns"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmmirror.com/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decamelize": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmmirror.com/decamelize/-/decamelize-1.2.0.tgz",
+      "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/dijkstrajs": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmmirror.com/dijkstrajs/-/dijkstrajs-1.0.3.tgz",
+      "integrity": "sha512-qiSlmBq9+BCdCA/L46dw8Uy93mloxsPSbwnm5yrKn2vMPiy8KyAskTF6zuV/j5BMsmOGZDPs7KjU+mjb670kfA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmmirror.com/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmmirror.com/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "license": "BSD-2-Clause",
+      "peer": true,
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/esdk-obs-browserjs": {
+      "version": "3.24.3",
+      "resolved": "https://registry.npmmirror.com/esdk-obs-browserjs/-/esdk-obs-browserjs-3.24.3.tgz",
+      "integrity": "sha512-ByK7uZqqeL0St6GCHrouPZUFBP4S+f+MiXkdwaqxAdEq3pDAcZ73p/rdqrF1WpUuSGmCCi57B9PXc2DmbWAM4g==",
+      "license": "Apache-2.0",
+      "peer": true,
+      "dependencies": {
+        "axios": "^0.26.1",
+        "blueimp-md5": "^2.18.0",
+        "crypto-js": "^4.2.0",
+        "js-base64": "^3.7.1",
+        "jssha": "^3.2.0",
+        "urijs": "^1.19.7"
+      },
+      "engines": {
+        "node": ">=0.12.7"
+      }
+    },
+    "node_modules/esm": {
+      "version": "3.2.25",
+      "resolved": "https://registry.npmmirror.com/esm/-/esm-3.2.25.tgz",
+      "integrity": "sha512-U1suiZ2oDVWv4zPO56S0NcR5QriEahGtdN2OR6FiOG4WJvcjBVFB0qI4+eKoWFH483PKGuLuu6V8Z4T5g63UVA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/eventemitter3": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmmirror.com/eventemitter3/-/eventemitter3-4.0.7.tgz",
+      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/events": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmmirror.com/events/-/events-3.3.0.tgz",
+      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.x"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmmirror.com/find-up/-/find-up-4.1.0.tgz",
+      "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "locate-path": "^5.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fmode-ng": {
+      "version": "0.0.83",
+      "resolved": "https://registry.npmmirror.com/fmode-ng/-/fmode-ng-0.0.83.tgz",
+      "integrity": "sha512-hFQ+5FNINOWsw+kSiQ7jKxe6lgm6H8/XffmSJb5NHXz/3Cphp6fjMwi7niDACXeunwWOvFwx6xsCcZl64NvFPw==",
+      "license": "COPYRIGHT © 未来飞马 未来全栈 www.fmode.cn All RIGHTS RESERVED",
+      "dependencies": {
+        "tslib": "^2.3.0"
+      },
+      "peerDependencies": {
+        "@amap/amap-jsapi-loader": "^1.0.1",
+        "@angular/animations": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "@angular/common": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "@angular/core": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "@angular/forms": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "@angular/material": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "@awesome-cordova-plugins/diagnostic": "^5.0.0 || ^6.0.0",
+        "@awesome-cordova-plugins/media-capture": "^5.0.0 || ^6.0.0 || ^7.0.0",
+        "@babylonjs/core": "7.2.3",
+        "@babylonjs/loaders": "7.2.3",
+        "@capacitor/camera": "^5.0.0 || ^6.0.0 || ^7.0.0",
+        "@capacitor/clipboard": "^5.0.0 || ^6.0.0 || ^7.0.0",
+        "@capacitor/filesystem": "^5.0.0 || ^6.0.0 || ^7.0.0",
+        "@ionic/angular": "^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0",
+        "@langchain/core": "^0.3.0 || ^1.0.0",
+        "@types/parse": "^3.0.9",
+        "@types/spark-md5": "^3.0.4",
+        "@wecom/jssdk": "^2.2.4",
+        "esdk-obs-browserjs": "^3.23.5",
+        "highlight.js": "^11.0.0",
+        "jquery": "^3.7.1",
+        "markdown-it": "^13.0.0 || ^14.0.0",
+        "markdown-it-abbr": "^1.0.4",
+        "markdown-it-deflist": "^2.1.0",
+        "markdown-it-footnote": "^3.0.3",
+        "markdown-it-imsize": "^2.0.1",
+        "markdown-it-ins": "^3.0.1",
+        "markdown-it-mark": "^3.0.1",
+        "markdown-it-mathjax": "^2.0.0",
+        "markdown-it-ruby": "^0.1.1",
+        "markdown-it-sub": "^1.0.0",
+        "markdown-it-sup": "^1.0.0",
+        "mathjax-full": "3.2.2",
+        "microsoft-cognitiveservices-speech-sdk": "^1.0.0 || ^2.0.0",
+        "ng-qrcode": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "ng-zorro-antd": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "parse": "^5.0.0",
+        "plantuml-encoder": "^1.4.0",
+        "qiniu-js": "^3.0.0 || ^2.0.0",
+        "recorder-core": "^1.2.23070100",
+        "spark-md5": "^3.0.2"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.9",
+      "resolved": "https://registry.npmmirror.com/follow-redirects/-/follow-redirects-1.15.9.tgz",
+      "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmmirror.com/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
+      "peer": true,
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/highlight.js": {
+      "version": "11.11.1",
+      "resolved": "https://registry.npmmirror.com/highlight.js/-/highlight.js-11.11.1.tgz",
+      "integrity": "sha512-Xwwo44whKBVCYoliBQwaPvtd/2tYFkRQtXDWj1nackaV2JPXx3L0+Jvd8/qCJ2p+ML0/XVkJ2q+Mr+UVdpJK5w==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmmirror.com/https-proxy-agent/-/https-proxy-agent-4.0.0.tgz",
+      "integrity": "sha512-zoDhWrkR3of1l9QAL8/scJZyLu8j/gBkcwcaQOZh7Gyh/+uJQzGVETdgT30akuwkpL8HTRfssqI3BZuV18teDg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "agent-base": "5",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/https-proxy-agent/node_modules/agent-base": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmmirror.com/agent-base/-/agent-base-5.1.1.tgz",
+      "integrity": "sha512-TMeqbNl2fMW0nMjTEPOwe3J/PRFP4vqeoNuQMG0HlMrtm5QxKqdvAkZ1pRBQ/ulIyDD5Yq0nJ7YbdD8ey0TO3g==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/idb-keyval": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmmirror.com/idb-keyval/-/idb-keyval-6.2.1.tgz",
+      "integrity": "sha512-8Sb3veuYCyrZL+VBt9LJfZjLUPWVvqn8tG28VqYNFCo43KHcKuq+b4EiXGeuaLAQWL2YmyDgMp2aSpH9JHsEQg==",
+      "license": "Apache-2.0",
+      "peer": true
+    },
+    "node_modules/ionicons": {
+      "version": "7.4.0",
+      "resolved": "https://registry.npmmirror.com/ionicons/-/ionicons-7.4.0.tgz",
+      "integrity": "sha512-ZK94MMqgzMCPPMhmk8Ouu6goyVHFIlw/ACP6oe3FrikcI0N7CX0xcwVaEbUc0G/v3W0shI93vo+9ve/KpvcNhQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@stencil/core": "^4.0.3"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/jquery": {
+      "version": "3.7.1",
+      "resolved": "https://registry.npmmirror.com/jquery/-/jquery-3.7.1.tgz",
+      "integrity": "sha512-m4avr8yL8kmFN8psrbFFFmB/If14iN5o9nw/NgnnM+kybDJpRsAynV2BsfpTYrTRysYUdADVD7CkUUizgkpLfg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/js-base64": {
+      "version": "3.7.7",
+      "resolved": "https://registry.npmmirror.com/js-base64/-/js-base64-3.7.7.tgz",
+      "integrity": "sha512-7rCnleh0z2CkXhH67J8K1Ytz0b2Y+yxTPL+/KOJoa20hfnVQ/3/T6W/KflYI4bRHRagNeXeU2bkNGI3v1oS/lw==",
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/js-tiktoken": {
+      "version": "1.0.20",
+      "resolved": "https://registry.npmmirror.com/js-tiktoken/-/js-tiktoken-1.0.20.tgz",
+      "integrity": "sha512-Xlaqhhs8VfCd6Sh7a1cFkZHQbYTLCwVJJWiHVxBYzLPxW0XsoxBy1hitmjkdIjD3Aon5BXLHFwU5O8WUx6HH+A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "base64-js": "^1.5.1"
+      }
+    },
+    "node_modules/jsonc-parser": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmmirror.com/jsonc-parser/-/jsonc-parser-3.3.1.tgz",
+      "integrity": "sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/jssha": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmmirror.com/jssha/-/jssha-3.3.1.tgz",
+      "integrity": "sha512-VCMZj12FCFMQYcFLPRm/0lOBbLi8uM2BhXPTqw3U4YAfs4AZfiApOoBLoN8cQE60Z50m1MYMTQVCfgF/KaCVhQ==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/langsmith": {
+      "version": "0.3.29",
+      "resolved": "https://registry.npmmirror.com/langsmith/-/langsmith-0.3.29.tgz",
+      "integrity": "sha512-JPF2B339qpYy9FyuY4Yz1aWYtgPlFc/a+VTj3L/JcFLHCiMP7+Ig8I9jO+o1QwVa+JU3iugL1RS0wwc+Glw0zA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/uuid": "^10.0.0",
+        "chalk": "^4.1.2",
+        "console-table-printer": "^2.12.1",
+        "p-queue": "^6.6.2",
+        "p-retry": "4",
+        "semver": "^7.6.3",
+        "uuid": "^10.0.0"
+      },
+      "peerDependencies": {
+        "openai": "*"
+      },
+      "peerDependenciesMeta": {
+        "openai": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/linkify-it": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmmirror.com/linkify-it/-/linkify-it-5.0.0.tgz",
+      "integrity": "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "uc.micro": "^2.0.0"
+      }
+    },
+    "node_modules/locate-path": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmmirror.com/locate-path/-/locate-path-5.0.0.tgz",
+      "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "p-locate": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/markdown-it": {
+      "version": "14.1.0",
+      "resolved": "https://registry.npmmirror.com/markdown-it/-/markdown-it-14.1.0.tgz",
+      "integrity": "sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "argparse": "^2.0.1",
+        "entities": "^4.4.0",
+        "linkify-it": "^5.0.0",
+        "mdurl": "^2.0.0",
+        "punycode.js": "^2.3.1",
+        "uc.micro": "^2.1.0"
+      },
+      "bin": {
+        "markdown-it": "bin/markdown-it.mjs"
+      }
+    },
+    "node_modules/markdown-it-abbr": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmmirror.com/markdown-it-abbr/-/markdown-it-abbr-1.0.4.tgz",
+      "integrity": "sha512-ZeA4Z4SaBbYysZap5iZcxKmlPL6bYA8grqhzJIHB1ikn7njnzaP8uwbtuXc4YXD5LicI4/2Xmc0VwmSiFV04gg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/markdown-it-deflist": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmmirror.com/markdown-it-deflist/-/markdown-it-deflist-2.1.0.tgz",
+      "integrity": "sha512-3OuqoRUlSxJiuQYu0cWTLHNhhq2xtoSFqsZK8plANg91+RJQU1ziQ6lA2LzmFAEes18uPBsHZpcX6We5l76Nzg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/markdown-it-footnote": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmmirror.com/markdown-it-footnote/-/markdown-it-footnote-3.0.3.tgz",
+      "integrity": "sha512-YZMSuCGVZAjzKMn+xqIco9d1cLGxbELHZ9do/TSYVzraooV8ypsppKNmUJ0fVH5ljkCInQAtFpm8Rb3eXSrt5w==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/markdown-it-imsize": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/markdown-it-imsize/-/markdown-it-imsize-2.0.1.tgz",
+      "integrity": "sha512-5SH90ademqcR8ifQCBXRCfIR4HGfZZOh5pO0j2TglulfSQH+SBXM4Iw/QlTUbSoUwVZArCYgECoMvktDS2kP3w==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/markdown-it-ins": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmmirror.com/markdown-it-ins/-/markdown-it-ins-3.0.1.tgz",
+      "integrity": "sha512-32SSfZqSzqyAmmQ4SHvhxbFqSzPDqsZgMHDwxqPzp+v+t8RsmqsBZRG+RfRQskJko9PfKC2/oxyOs4Yg/CfiRw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/markdown-it-mark": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmmirror.com/markdown-it-mark/-/markdown-it-mark-3.0.1.tgz",
+      "integrity": "sha512-HyxjAu6BRsdt6Xcv6TKVQnkz/E70TdGXEFHRYBGLncRE9lBFwDNLVtFojKxjJWgJ+5XxUwLaHXy+2sGBbDn+4A==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/markdown-it-mathjax": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/markdown-it-mathjax/-/markdown-it-mathjax-2.0.0.tgz",
+      "integrity": "sha512-Fafv7TnMENccWYTNjMZzV4BzONPxpK9Mknr1iMEK6m7PI5a5UTCOFctPzx7Nhv81fFzYEY8WHDkSu9n43fTV9g==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/markdown-it-ruby": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmmirror.com/markdown-it-ruby/-/markdown-it-ruby-0.1.1.tgz",
+      "integrity": "sha512-ct8t/Drt7scv20VdaQtOhpBOC2SDICaW8E/WQS8kY2eUdu0eoDwW8ugXcCy8Vku4Y5CuA5qrewlHpwaFsJxbpQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/markdown-it-sub": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/markdown-it-sub/-/markdown-it-sub-1.0.0.tgz",
+      "integrity": "sha512-z2Rm/LzEE1wzwTSDrI+FlPEveAAbgdAdPhdWarq/ZGJrGW/uCQbKAnhoCsE4hAbc3SEym26+W2z/VQB0cQiA9Q==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/markdown-it-sup": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/markdown-it-sup/-/markdown-it-sup-1.0.0.tgz",
+      "integrity": "sha512-E32m0nV9iyhRR7CrhnzL5msqic7rL1juWre6TQNxsnApg7Uf+F97JOKxUijg5YwXz86lZ0mqfOnutoryyNdntQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/mathjax-full": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmmirror.com/mathjax-full/-/mathjax-full-3.2.2.tgz",
+      "integrity": "sha512-+LfG9Fik+OuI8SLwsiR02IVdjcnRCy5MufYLi0C3TdMT56L/pjB0alMVGgoWJF8pN9Rc7FESycZB9BMNWIid5w==",
+      "license": "Apache-2.0",
+      "peer": true,
+      "dependencies": {
+        "esm": "^3.2.25",
+        "mhchemparser": "^4.1.0",
+        "mj-context-menu": "^0.6.1",
+        "speech-rule-engine": "^4.0.6"
+      }
+    },
+    "node_modules/mdurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/mdurl/-/mdurl-2.0.0.tgz",
+      "integrity": "sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/mhchemparser": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmmirror.com/mhchemparser/-/mhchemparser-4.2.1.tgz",
+      "integrity": "sha512-kYmyrCirqJf3zZ9t/0wGgRZ4/ZJw//VwaRVGA75C4nhE60vtnIzhl9J9ndkX/h6hxSN7pjg/cE0VxbnNM+bnDQ==",
+      "license": "Apache-2.0",
+      "peer": true
+    },
+    "node_modules/microsoft-cognitiveservices-speech-sdk": {
+      "version": "1.44.0",
+      "resolved": "https://registry.npmmirror.com/microsoft-cognitiveservices-speech-sdk/-/microsoft-cognitiveservices-speech-sdk-1.44.0.tgz",
+      "integrity": "sha512-M6OdgrJ+2+OLg+Ow8CWV1+oKtaWFF0H+Jzpta/jp+3XLCv+LH42PisbCDTjYhtgRXlwd8sxaZrUa0HFIkl9BSw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/webrtc": "^0.0.37",
+        "agent-base": "^6.0.1",
+        "bent": "^7.3.12",
+        "https-proxy-agent": "^4.0.0",
+        "uuid": "^9.0.0",
+        "ws": "^7.5.6"
+      }
+    },
+    "node_modules/microsoft-cognitiveservices-speech-sdk/node_modules/uuid": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmmirror.com/uuid/-/uuid-9.0.1.tgz",
+      "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
+    "node_modules/mj-context-menu": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmmirror.com/mj-context-menu/-/mj-context-menu-0.6.1.tgz",
+      "integrity": "sha512-7NO5s6n10TIV96d4g2uDpG7ZDpIhMh0QNfGdJw/W47JswFcosz457wqz/b5sAKvl12sxINGFCn80NZHKwxQEXA==",
+      "license": "Apache-2.0",
+      "peer": true
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/mustache": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmmirror.com/mustache/-/mustache-4.2.0.tgz",
+      "integrity": "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==",
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "mustache": "bin/mustache"
+      }
+    },
+    "node_modules/ng-qrcode": {
+      "version": "19.0.1",
+      "resolved": "https://registry.npmmirror.com/ng-qrcode/-/ng-qrcode-19.0.1.tgz",
+      "integrity": "sha512-8m4dqxSY7OSxJA7X0BEC7zJVLZ1QRw4ez5m440J7yq3HA8ixIa/hvQUjQLXJjbGUl33bjR9HNUPd9ZKxBmxnyA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "qrcode": "^1.5.3",
+        "tslib": "^2.6.2"
+      },
+      "peerDependencies": {
+        "@angular/common": ">=19 <20",
+        "@angular/core": ">=19 <20"
+      }
+    },
+    "node_modules/ng-zorro-antd": {
+      "version": "19.3.0",
+      "resolved": "https://registry.npmmirror.com/ng-zorro-antd/-/ng-zorro-antd-19.3.0.tgz",
+      "integrity": "sha512-iwizG1uYPPVy/jtUpvpIKGUbTwfxZZO4T5jWcL6201NJuAT3eLHIgqZFXNxXBJWkLRmZmPYaZeWfCy042jV8fA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@angular/cdk": "^19.0.0",
+        "@ant-design/icons-angular": "^19.0.0",
+        "@ctrl/tinycolor": "^3.6.0",
+        "date-fns": "^2.16.1",
+        "tslib": "^2.3.0"
+      },
+      "peerDependencies": {
+        "@angular/animations": "^19.0.0",
+        "@angular/common": "^19.0.0",
+        "@angular/core": "^19.0.0",
+        "@angular/forms": "^19.0.0",
+        "@angular/platform-browser": "^19.0.0",
+        "@angular/router": "^19.0.0"
+      }
+    },
+    "node_modules/p-finally": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/p-finally/-/p-finally-1.0.0.tgz",
+      "integrity": "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmmirror.com/p-limit/-/p-limit-2.3.0.tgz",
+      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "p-try": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmmirror.com/p-locate/-/p-locate-4.1.0.tgz",
+      "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "p-limit": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/p-queue": {
+      "version": "6.6.2",
+      "resolved": "https://registry.npmmirror.com/p-queue/-/p-queue-6.6.2.tgz",
+      "integrity": "sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "eventemitter3": "^4.0.4",
+        "p-timeout": "^3.2.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-retry": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmmirror.com/p-retry/-/p-retry-4.6.2.tgz",
+      "integrity": "sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/retry": "0.12.0",
+        "retry": "^0.13.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/p-timeout": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmmirror.com/p-timeout/-/p-timeout-3.2.0.tgz",
+      "integrity": "sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "p-finally": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/p-try": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmmirror.com/p-try/-/p-try-2.2.0.tgz",
+      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/parse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmmirror.com/parse/-/parse-5.3.0.tgz",
+      "integrity": "sha512-mWBnE6hHJhdvlx5KPQcYgCGRdgqKhPw+5fSC0j7vOfse3Lkh3xtDwOfmDpvv2LXZVBj72G/mgVKMRmbAICRzkQ==",
+      "license": "Apache-2.0",
+      "peer": true,
+      "dependencies": {
+        "@babel/runtime-corejs3": "7.24.7",
+        "idb-keyval": "6.2.1",
+        "react-native-crypto-js": "1.0.0",
+        "uuid": "10.0.0",
+        "ws": "8.17.1",
+        "xmlhttprequest": "1.8.0"
+      },
+      "engines": {
+        "node": "18 || 19 || 20 || 22"
+      },
+      "optionalDependencies": {
+        "crypto-js": "4.2.0"
+      }
+    },
+    "node_modules/parse/node_modules/ws": {
+      "version": "8.17.1",
+      "resolved": "https://registry.npmmirror.com/ws/-/ws-8.17.1.tgz",
+      "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/parse5": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmmirror.com/parse5/-/parse5-7.3.0.tgz",
+      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "entities": "^6.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
+    "node_modules/parse5/node_modules/entities": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmmirror.com/entities/-/entities-6.0.0.tgz",
+      "integrity": "sha512-aKstq2TDOndCn4diEyp9Uq/Flu2i1GlLkc6XIDQSDMuaFE3OPW5OphLCyQ5SpSJZTb4reN+kTcYru5yIfXoRPw==",
+      "license": "BSD-2-Clause",
+      "peer": true,
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmmirror.com/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/plantuml-encoder": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmmirror.com/plantuml-encoder/-/plantuml-encoder-1.4.0.tgz",
+      "integrity": "sha512-sxMwpDw/ySY1WB2CE3+IdMuEcWibJ72DDOsXLkSmEaSzwEUaYBT6DWgOfBiHGCux4q433X6+OEFWjlVqp7gL6g==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/pngjs": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmmirror.com/pngjs/-/pngjs-5.0.0.tgz",
+      "integrity": "sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/punycode.js": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmmirror.com/punycode.js/-/punycode.js-2.3.1.tgz",
+      "integrity": "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/qiniu-js": {
+      "version": "3.4.2",
+      "resolved": "https://registry.npmmirror.com/qiniu-js/-/qiniu-js-3.4.2.tgz",
+      "integrity": "sha512-Gu94/4adN2FnM9VpTgLsgvS3KN+2ZV9gCxlmrKICMI7VqcAwTsy3+9eBLLk8WueMYwniyg8rELjdxNf0wABUHg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/runtime-corejs2": "^7.10.2",
+        "querystring": "^0.2.1",
+        "spark-md5": "^3.0.0"
+      }
+    },
+    "node_modules/qrcode": {
+      "version": "1.5.4",
+      "resolved": "https://registry.npmmirror.com/qrcode/-/qrcode-1.5.4.tgz",
+      "integrity": "sha512-1ca71Zgiu6ORjHqFBDpnSMTR2ReToX4l1Au1VFLyVeBTFavzQnv5JxMFr3ukHVKpSrSA2MCk0lNJSykjUfz7Zg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "dijkstrajs": "^1.0.1",
+        "pngjs": "^5.0.0",
+        "yargs": "^15.3.1"
+      },
+      "bin": {
+        "qrcode": "bin/qrcode"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/querystring": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmmirror.com/querystring/-/querystring-0.2.1.tgz",
+      "integrity": "sha512-wkvS7mL/JMugcup3/rMitHmd9ecIGd2lhFhK9N3UUQ450h66d1r3Y9nvXzQAW1Lq+wyx61k/1pfKS5KuKiyEbg==",
+      "deprecated": "The querystring API is considered Legacy. new code should use the URLSearchParams API instead.",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.4.x"
+      }
+    },
+    "node_modules/react-native-crypto-js": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/react-native-crypto-js/-/react-native-crypto-js-1.0.0.tgz",
+      "integrity": "sha512-FNbLuG/HAdapQoybeZSoes1PWdOj0w242gb+e1R0hicf3Gyj/Mf8M9NaED2AnXVOX01b2FXomwUiw1xP1K+8sA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/recorder-core": {
+      "version": "1.3.25011100",
+      "resolved": "https://registry.npmmirror.com/recorder-core/-/recorder-core-1.3.25011100.tgz",
+      "integrity": "sha512-trXsCH0zurhoizT4Z22C0OsM0SDOW+2OvtgRxeLQFwxoFeqFjDjYZsbZEZUiKMJLhBvamI4K7Ic+qZ2LBo74TA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/regenerator-runtime": {
+      "version": "0.14.1",
+      "resolved": "https://registry.npmmirror.com/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
+      "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmmirror.com/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/require-main-filename": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/require-main-filename/-/require-main-filename-2.0.0.tgz",
+      "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/retry": {
+      "version": "0.13.1",
+      "resolved": "https://registry.npmmirror.com/retry/-/retry-0.13.1.tgz",
+      "integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/rxjs": {
+      "version": "7.8.2",
+      "resolved": "https://registry.npmmirror.com/rxjs/-/rxjs-7.8.2.tgz",
+      "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==",
+      "license": "Apache-2.0",
+      "peer": true,
+      "dependencies": {
+        "tslib": "^2.1.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmmirror.com/semver/-/semver-7.7.2.tgz",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "license": "ISC",
+      "peer": true,
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/simple-wcswidth": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/simple-wcswidth/-/simple-wcswidth-1.0.1.tgz",
+      "integrity": "sha512-xMO/8eNREtaROt7tJvWJqHBDTMFN4eiQ5I4JRMuilwfnFcV5W9u7RUkueNkdw0jPqGMX36iCywelS5yilTuOxg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/spark-md5": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmmirror.com/spark-md5/-/spark-md5-3.0.2.tgz",
+      "integrity": "sha512-wcFzz9cDfbuqe0FZzfi2or1sgyIrsDwmPwfZC4hiNidPdPINjeUwNfv5kldczoEAcjl9Y1L3SM7Uz2PUEQzxQw==",
+      "license": "(WTFPL OR MIT)",
+      "peer": true
+    },
+    "node_modules/speech-rule-engine": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmmirror.com/speech-rule-engine/-/speech-rule-engine-4.1.2.tgz",
+      "integrity": "sha512-S6ji+flMEga+1QU79NDbwZ8Ivf0S/MpupQQiIC0rTpU/ZTKgcajijJJb1OcByBQDjrXCN1/DJtGz4ZJeBMPGJw==",
+      "license": "Apache-2.0",
+      "peer": true,
+      "dependencies": {
+        "@xmldom/xmldom": "0.9.8",
+        "commander": "13.1.0",
+        "wicked-good-xpath": "1.3.0"
+      },
+      "bin": {
+        "sre": "bin/sre"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmmirror.com/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmmirror.com/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
+    "node_modules/typescript": {
+      "version": "5.8.3",
+      "resolved": "https://registry.npmmirror.com/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/uc.micro": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmmirror.com/uc.micro/-/uc.micro-2.1.0.tgz",
+      "integrity": "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmmirror.com/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/urijs": {
+      "version": "1.19.11",
+      "resolved": "https://registry.npmmirror.com/urijs/-/urijs-1.19.11.tgz",
+      "integrity": "sha512-HXgFDgDommxn5/bIv0cnQZsPhHDA90NPHD6+c/v21U5+Sx5hoP8+dP9IZXBU1gIfvdRfhG8cel9QNPeionfcCQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/uuid": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmmirror.com/uuid/-/uuid-10.0.0.tgz",
+      "integrity": "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
+    "node_modules/which-module": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/which-module/-/which-module-2.0.1.tgz",
+      "integrity": "sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/wicked-good-xpath": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmmirror.com/wicked-good-xpath/-/wicked-good-xpath-1.3.0.tgz",
+      "integrity": "sha512-Gd9+TUn5nXdwj/hFsPVx5cuHHiF5Bwuc30jZ4+ronF1qHK5O7HD0sgmXWSEgwKquT3ClLoKPVbO6qGwVwLzvAw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/wrap-ansi": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmmirror.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
+      "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/ws": {
+      "version": "7.5.10",
+      "resolved": "https://registry.npmmirror.com/ws/-/ws-7.5.10.tgz",
+      "integrity": "sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8.3.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": "^5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xmlhttprequest": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmmirror.com/xmlhttprequest/-/xmlhttprequest-1.8.0.tgz",
+      "integrity": "sha512-58Im/U0mlVBLM38NdZjHyhuMtCqa61469k2YP/AaPbvCoV9aQGUpbJBj1QRm2ytRiVQBD/fsw7L2bJGDVQswBA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmmirror.com/y18n/-/y18n-4.0.3.tgz",
+      "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/yargs": {
+      "version": "15.4.1",
+      "resolved": "https://registry.npmmirror.com/yargs/-/yargs-15.4.1.tgz",
+      "integrity": "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "cliui": "^6.0.0",
+        "decamelize": "^1.2.0",
+        "find-up": "^4.1.0",
+        "get-caller-file": "^2.0.1",
+        "require-directory": "^2.1.1",
+        "require-main-filename": "^2.0.0",
+        "set-blocking": "^2.0.0",
+        "string-width": "^4.2.0",
+        "which-module": "^2.0.0",
+        "y18n": "^4.0.0",
+        "yargs-parser": "^18.1.2"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "18.1.3",
+      "resolved": "https://registry.npmmirror.com/yargs-parser/-/yargs-parser-18.1.3.tgz",
+      "integrity": "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "camelcase": "^5.0.0",
+        "decamelize": "^1.2.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/yargs-parser/node_modules/camelcase": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmmirror.com/camelcase/-/camelcase-5.3.1.tgz",
+      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.30",
+      "resolved": "https://registry.npmmirror.com/zod/-/zod-3.25.30.tgz",
+      "integrity": "sha512-VolhdEtu6TJr/fzGuHA/SZ5ixvXqA6ADOG9VRcQ3rdOKmF5hkmcJbyaQjUH5BgmpA9gej++zYRX7zjSmdReIwA==",
+      "license": "MIT",
+      "peer": true,
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.24.5",
+      "resolved": "https://registry.npmmirror.com/zod-to-json-schema/-/zod-to-json-schema-3.24.5.tgz",
+      "integrity": "sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g==",
+      "license": "ISC",
+      "peer": true,
+      "peerDependencies": {
+        "zod": "^3.24.1"
+      }
+    },
+    "node_modules/zone.js": {
+      "version": "0.15.1",
+      "resolved": "https://registry.npmmirror.com/zone.js/-/zone.js-0.15.1.tgz",
+      "integrity": "sha512-XE96n56IQpJM7NAoXswY3XRLcWFW83xe0BiAOeMD7K5k5xecOeul3Qcpx6GqEeeHNkW5DWL5zOyTbEfB4eti8w==",
+      "license": "MIT",
+      "peer": true
+    }
+  }
+}

node_modules/@amap/amap-jsapi-loader/.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "editor.tabSize": 4,
+  "prettier.tabWidth": 4
+}

node_modules/@amap/amap-jsapi-loader/README.md

@@ -0,0 +1,111 @@
+# amap-jsapi-loader
+amap-jsapi-loader 是高德开放平台官网提供的地图 JSAPI 的加载器，可帮助开发者快速定位、有效避免加载引用地图 JSAPI 各种错误用法。
+
+
+该加载器具有以下特性：
+* 支持以 普通JS 和 npm包 两种方式使用；
+* 有效避免错误异步加载导致的 JSAPI 资源加载不完整问题；
+* 对于加载混用多个版本 JSAPI 的错误用法给予报错处理；
+* 对于不合法加载引用 JSAPI 给予报错处理；
+* 支持指定 JSAPI 版本；
+* 支持插件加载；
+* 允许多次执行加载操作，网络资源不会重复请求，便于大型工程模块管理；
+
+
+# USAGE
+
+## AMapLoader.load方法参数说明
+```js
+AMapLoader.load({
+    "key": "",              // 申请好的Web端开发者Key，首次调用 load 时必填
+    "version": "2.0",   // 指定要加载的 JSAPI 的版本，缺省时默认为 1.4.15
+    "plugins": []           // 需要使用的的插件列表，如比例尺'AMap.Scale'等
+    "AMapUI": {             // 是否加载 AMapUI，缺省不加载
+        "version": '1.1',   // AMapUI 缺省 1.1
+        "plugins":[],       // 需要加载的 AMapUI ui插件
+    },
+    "Loca":{                // 是否加载 Loca， 缺省不加载
+        "version": '1.3.2'  // Loca 版本，缺省 1.3.2
+    },
+}).then(()=>{
+    window.AMap.xx;
+    window.AMapUI.xx;
+    window.Loca.xx
+});
+
+```
+
+## AMapUI
+
+AMapUI 用法和官网有一点点区别。通过 AMapUI.xx 来获取组件
+```js
+AMapLoader.load({
+    key: '',//首次load必填
+    version: '2.0',
+    AMapUI: {
+        version: '1.1',
+        plugins: ['overlay/SimpleMarker'],
+    }
+}).then((AMap) => {
+    map = new AMap.Map('container');
+
+    // !!! 通过 AMap.SimpleMarker 获取组件
+    new AMapUI.SimpleMarker({
+        //前景文字
+        iconLabel: 'A',
+        //图标主题
+        iconTheme: 'default',
+        //背景图标样式
+        iconStyle: 'red',
+        map: map,
+        position: map.getCenter()
+    });
+}).catch((e) => {
+    console.error(e);
+});
+```
+
+
+# 使用
+#### 以普通 JS 方式使用 Loader
+尚未发布在线Loader，可将 dist/index.js 复制到项目下
+```
+<script src="../dist/index.js"></script>
+<script>
+    AMapLoader.load({
+        key:'',//首次load必填
+        version:'2.0',
+        plugins:['AMap.Scale']
+    }).then((AMap)=>{
+        map = new AMap.Map('container');
+        map.addControl(new AMap.Scale())
+    }).catch((e)=>{
+        console.error(e);
+    });   
+</script>
+```
+#### 以 NPM 包方式使用 Loader
+安装
+```
+tnpm i @alife/amap-jsapi-loader --save-dev
+```
+使用
+```
+import AMapLoader from '@alife/amap-jsapi-loader';
+
+AMapLoader.load().then((AMap)=>{
+    map = new AMap.Map('container');
+}).catch(e=>{
+    console.log(e);
+})
+
+```
+
+# 相关链接：
+地&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;图 JSAPI：  &nbsp;&nbsp;[示例中心](https://lbs.amap.com/demo-center/js-api)&nbsp;&nbsp;&nbsp;&nbsp;[教程](https://lbs.amap.com/api/javascript-api/summary)&nbsp;&nbsp;&nbsp;&nbsp;[参考手册](https://lbs.amap.com/api/javascript-api/reference/map)
+
+
+
+数据可视化 JSAPI：  &nbsp;&nbsp;[示例中心](https://lbs.amap.com/demo-center/loca-api)&nbsp;&nbsp;&nbsp;&nbsp;[教程](https://lbs.amap.com/api/loca-api/prod_intro)&nbsp;&nbsp;&nbsp;&nbsp;[参考手册](https://lbs.amap.com/api/loca-api/guide/baselayer)
+
+

node_modules/@amap/amap-jsapi-loader/dist/index.js

@@ -0,0 +1,11 @@
+'use strict';(function(m,p){"object"===typeof exports&&"undefined"!==typeof module?module.exports=p():"function"===typeof define&&define.amd?define(p):(m=m||self,m.AMapLoader=p())})(this,function(){function m(a){var b=[];a.AMapUI&&b.push(p(a.AMapUI));a.Loca&&b.push(r(a.Loca));return Promise.all(b)}function p(a){return new Promise(function(h,c){var f=[];if(a.plugins)for(var e=0;e<a.plugins.length;e+=1)-1==d.AMapUI.plugins.indexOf(a.plugins[e])&&f.push(a.plugins[e]);if(g.AMapUI===b.failed)c("\u524d\u6b21\u8bf7\u6c42 AMapUI \u5931\u8d25");
+else if(g.AMapUI===b.notload){g.AMapUI=b.loading;d.AMapUI.version=a.version||d.AMapUI.version;e=d.AMapUI.version;var l=document.body||document.head,k=document.createElement("script");k.type="text/javascript";k.src="https://webapi.amap.com/ui/"+e+"/main.js";k.onerror=function(a){g.AMapUI=b.failed;c("\u8bf7\u6c42 AMapUI \u5931\u8d25")};k.onload=function(){g.AMapUI=b.loaded;if(f.length)window.AMapUI.loadUI(f,function(){for(var a=0,b=f.length;a<b;a++){var c=f[a].split("/").slice(-1)[0];window.AMapUI[c]=
+arguments[a]}for(h();n.AMapUI.length;)n.AMapUI.splice(0,1)[0]()});else for(h();n.AMapUI.length;)n.AMapUI.splice(0,1)[0]()};l.appendChild(k)}else g.AMapUI===b.loaded?a.version&&a.version!==d.AMapUI.version?c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c AMapUI \u6df7\u7528"):f.length?window.AMapUI.loadUI(f,function(){for(var a=0,b=f.length;a<b;a++){var c=f[a].split("/").slice(-1)[0];window.AMapUI[c]=arguments[a]}h()}):h():a.version&&a.version!==d.AMapUI.version?c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c AMapUI \u6df7\u7528"):
+n.AMapUI.push(function(a){a?c(a):f.length?window.AMapUI.loadUI(f,function(){for(var a=0,b=f.length;a<b;a++){var c=f[a].split("/").slice(-1)[0];window.AMapUI[c]=arguments[a]}h()}):h()})})}function r(a){return new Promise(function(h,c){if(g.Loca===b.failed)c("\u524d\u6b21\u8bf7\u6c42 Loca \u5931\u8d25");else if(g.Loca===b.notload){g.Loca=b.loading;d.Loca.version=a.version||d.Loca.version;var f=d.Loca.version,e=d.AMap.version.startsWith("2"),l=f.startsWith("2");if(e&&!l||!e&&l)c("JSAPI \u4e0e Loca \u7248\u672c\u4e0d\u5bf9\u5e94\uff01\uff01");
+else{e=d.key;l=document.body||document.head;var k=document.createElement("script");k.type="text/javascript";k.src="https://webapi.amap.com/loca?v="+f+"&key="+e;k.onerror=function(a){g.Loca=b.failed;c("\u8bf7\u6c42 AMapUI \u5931\u8d25")};k.onload=function(){g.Loca=b.loaded;for(h();n.Loca.length;)n.Loca.splice(0,1)[0]()};l.appendChild(k)}}else g.Loca===b.loaded?a.version&&a.version!==d.Loca.version?c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c Loca \u6df7\u7528"):h():a.version&&a.version!==d.Loca.version?
+c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c Loca \u6df7\u7528"):n.Loca.push(function(a){a?c(a):c()})})}if(!window)throw Error("AMap JSAPI can only be used in Browser.");var b;(function(a){a.notload="notload";a.loading="loading";a.loaded="loaded";a.failed="failed"})(b||(b={}));var d={key:"",AMap:{version:"1.4.15",plugins:[]},AMapUI:{version:"1.1",plugins:[]},Loca:{version:"1.3.2"}},g={AMap:b.notload,AMapUI:b.notload,Loca:b.notload},n={AMap:[],AMapUI:[],Loca:[]},q=[],t=function(a){"function"==typeof a&&
+(g.AMap===b.loaded?a(window.AMap):q.push(a))};return{load:function(a){return new Promise(function(h,c){if(g.AMap==b.failed)c("");else if(g.AMap==b.notload){var f=a.key,e=a.version,l=a.plugins;f?(window.AMap&&"lbs.amap.com"!==location.host&&c("\u7981\u6b62\u591a\u79cdAPI\u52a0\u8f7d\u65b9\u5f0f\u6df7\u7528"),d.key=f,d.AMap.version=e||d.AMap.version,d.AMap.plugins=l||d.AMap.plugins,g.AMap=b.loading,e=document.body||document.head,window.___onAPILoaded=function(d){delete window.___onAPILoaded;if(d)g.AMap=
+b.failed,c(d);else for(g.AMap=b.loaded,m(a).then(function(){h(window.AMap)})["catch"](c);q.length;)q.splice(0,1)[0]()},l=document.createElement("script"),l.type="text/javascript",l.src="https://webapi.amap.com/maps?callback=___onAPILoaded&v="+d.AMap.version+"&key="+f+"&plugin="+d.AMap.plugins.join(","),l.onerror=function(a){g.AMap=b.failed;c(a)},e.appendChild(l)):c("\u8bf7\u586b\u5199key")}else if(g.AMap==b.loaded)if(a.key&&a.key!==d.key)c("\u591a\u4e2a\u4e0d\u4e00\u81f4\u7684 key");else if(a.version&&
+a.version!==d.AMap.version)c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c JSAPI \u6df7\u7528");else{f=[];if(a.plugins)for(e=0;e<a.plugins.length;e+=1)-1==d.AMap.plugins.indexOf(a.plugins[e])&&f.push(a.plugins[e]);if(f.length)window.AMap.plugin(f,function(){m(a).then(function(){h(window.AMap)})["catch"](c)});else m(a).then(function(){h(window.AMap)})["catch"](c)}else if(a.key&&a.key!==d.key)c("\u591a\u4e2a\u4e0d\u4e00\u81f4\u7684 key");else if(a.version&&a.version!==d.AMap.version)c("\u4e0d\u5141\u8bb8\u591a\u4e2a\u7248\u672c JSAPI \u6df7\u7528");
+else{var k=[];if(a.plugins)for(e=0;e<a.plugins.length;e+=1)-1==d.AMap.plugins.indexOf(a.plugins[e])&&k.push(a.plugins[e]);t(function(){if(k.length)window.AMap.plugin(k,function(){m(a).then(function(){h(window.AMap)})["catch"](c)});else m(a).then(function(){h(window.AMap)})["catch"](c)})}})},reset:function(){delete window.AMap;delete window.AMapUI;delete window.Loca;d={key:"",AMap:{version:"1.4.15",plugins:[]},AMapUI:{version:"1.1",plugins:[]},Loca:{version:"1.3.2"}};g={AMap:b.notload,AMapUI:b.notload,
+Loca:b.notload};n={AMap:[],AMapUI:[],Loca:[]}}}})

node_modules/@amap/amap-jsapi-loader/example/AMapUI.html

@@ -0,0 +1,69 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>JSAPI Loader</title>
+    <style>
+        html,
+        body,
+        #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+
+<body>
+    <div id="container" tabindex="0"></div>
+
+    <script src="../dist/index.js"></script>
+    <script>
+        AMapLoader.load({
+            key: '',//首次load必填
+            version: '2.0Beta',
+            plugins: ['AMap.Scale'],
+            AMapUI: {
+                plugins: ['overlay/SimpleMarker'],
+            }
+        }).then((AMap) => {
+            map = new AMap.Map('container');
+            map.addControl(new AMap.Scale());
+            new AMapUI.SimpleMarker({
+
+                //前景文字
+                iconLabel: 'A',
+
+                //图标主题
+                iconTheme: 'default',
+
+                //背景图标样式
+                iconStyle: 'red',
+
+                //...其他Marker选项...，不包括content
+                map: map,
+                position: map.getCenter()
+            });
+        }).catch((e) => {
+            console.error(e);
+        });
+        setTimeout(function () {
+            AMapLoader.load({
+                plugins: ['AMap.MapType']
+            }).then((AMap) => {
+                map.addControl(new AMap.MapType())
+            }).catch((e) => {
+                console.error(e);
+            });
+        }, 5000);
+
+    </script>
+
+
+    </script>
+</body>
+
+</html>

node_modules/@amap/amap-jsapi-loader/example/Loca.html

@@ -0,0 +1,76 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>JSAPI Loader</title>
+    <style>
+        html,
+        body,
+        #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+
+<body>
+    <div id="container" tabindex="0"></div>
+    <script src="https://a.amap.com/Loca/static/mock/districts.js"></script>
+    <script src="../dist/index.js"></script>
+    <script>
+        AMapLoader.load({
+            key: 'd3c5511c8a102496b1fdb985e6ca1cd7',//首次load必填
+            // version: '2.0',
+            Loca: {
+                version: '2.0.0beta'
+            }
+        }).then((AMap) => {
+            var map = new AMap.Map('container', {
+                zoom: 4,
+                center: [107.4976, 32.1697],
+                features: ['bg', 'road'],
+                // Loca 自 1.2.0 起 viewMode 模式默认为 3D，如需 2D 模式，请显示配置。
+                // viewMode: '3D'
+            });
+
+            var layer = new Loca.PointLayer({
+                map: map
+            });
+
+            layer.setData(districts, {
+                // 指定经纬度所在字段
+                lnglat: 'center'
+            });
+
+            layer.setOptions({
+                style: {
+                    // 圆形半径，单位像素
+                    radius: 5,
+                    // 填充颜色
+                    color: '#07E8E4',
+                    // 描边颜色
+                    borderColor: '#5DFBF9',
+                    // 描边宽度，单位像素
+                    borderWidth: 1,
+                    // 透明度 [0-1]
+                    opacity: 0.9,
+                }
+            });
+
+            layer.render();
+
+        }).catch((e) => {
+            console.error(e);
+        });
+
+    </script>
+
+
+    </script>
+</body>
+
+</html>

node_modules/@amap/amap-jsapi-loader/example/Multi.html

@@ -0,0 +1,94 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>JSAPI Loader</title>
+    <style>
+        html,
+        body,
+        #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+
+<body>
+    <div id="container" tabindex="0"></div>
+    <script src="https://a.amap.com/Loca/static/mock/districts.js"></script>
+    <script src="../dist/index.js"></script>
+    <script>
+        AMapLoader.load({
+            key: '',//首次load必填
+            version: '1.4.15',
+            AMapUI: {
+                plugins: ['overlay/SimpleMarker'],
+            },
+            Loca: {
+                version: '1.3.2'
+            }
+        }).then((AMap) => {
+            var map = new AMap.Map('container', {
+                zoom: 4,
+                center: [107.4976, 32.1697],
+                features: ['bg', 'road'],
+                // Loca 自 1.2.0 起 viewMode 模式默认为 3D，如需 2D 模式，请显示配置。
+                // viewMode: '3D'
+            });
+
+            new AMapUI.SimpleMarker({
+
+                //前景文字
+                iconLabel: 'A',
+
+                //图标主题
+                iconTheme: 'default',
+
+                //背景图标样式
+                iconStyle: 'red',
+
+                //...其他Marker选项...，不包括content
+                map: map,
+                position: map.getCenter()
+            });
+            var layer = new Loca.PointLayer({
+                map: map
+            });
+
+            layer.setData(districts, {
+                // 指定经纬度所在字段
+                lnglat: 'center'
+            });
+
+            layer.setOptions({
+                style: {
+                    // 圆形半径，单位像素
+                    radius: 5,
+                    // 填充颜色
+                    color: '#07E8E4',
+                    // 描边颜色
+                    borderColor: '#5DFBF9',
+                    // 描边宽度，单位像素
+                    borderWidth: 1,
+                    // 透明度 [0-1]
+                    opacity: 0.9,
+                }
+            });
+
+            layer.render();
+
+        }).catch((e) => {
+            console.error(e);
+        });
+
+    </script>
+
+
+    </script>
+</body>
+
+</html>

node_modules/@amap/amap-jsapi-loader/example/example-es6.html

@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>JSAPI Loader - ES6</title>
+    <style>
+        html, body, #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+<body>
+<div id="container" tabindex="0"></div>
+<script type="module">
+    import AMapLoader from '../src/index.js';
+    AMapLoader.load({
+        key:'',//必填
+        version:'2.0',
+        plugins:['AMap.Scale']
+    }).then((AMap)=>{
+        debugger
+        var map = new AMap.Map('container');
+        map.addControl(new AMap.Scale())
+    }).catch((e)=>{
+        console.error(e);
+    });
+</script>
+
+
+</script>
+</body>
+</html>

node_modules/@amap/amap-jsapi-loader/example/example.html

@@ -0,0 +1,46 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>AMap JSAPI Loader</title>
+    <style>
+        html, body, #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+<body>
+<div id="container" tabindex="0"></div>
+
+<script src="https://webapi.amap.com/loader.js"></script>
+<script>
+    AMapLoader.load({ //首次调用 load
+        key:'你申请的高德开放平台 Web 端 key',//首次load key为必填
+        version:'2.0',
+        plugins:['AMap.Scale','AMap.ToolBar']
+    }).then((AMap)=>{
+        map = new AMap.Map('container');
+        map.addControl(new AMap.Scale())
+        map.addControl(new AMap.ToolBar())
+        map.add(new AMap.Marker({
+            position:map.getCenter()
+        }));
+    }).catch((e)=>{
+        console.error(e);
+    });
+   
+    AMapLoader.load({ //可多次调用load
+        plugins:['AMap.MapType']
+    }).then((AMap)=>{
+        map.addControl(new AMap.MapType())
+    }).catch((e)=>{
+        console.error(e);
+    });
+   
+</script>
+</body>
+</html>

node_modules/@amap/amap-jsapi-loader/example/test.html

@@ -0,0 +1,287 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="initial-scale=1.0, user-scalable=no, width=device-width">
+    <title>JSAPI Loader</title>
+    <style>
+        html,
+        body,
+        #container {
+            height: 100%;
+            width: 100%;
+            margin: 0;
+        }
+    </style>
+</head>
+
+<body>
+    <div id="mocha"></div>
+
+    <link rel="stylesheet" href="./libs/mocha.min.css" />
+    <script src="./libs/chai.min.js"></script>
+    <script src="./libs/mocha.min.js"></script>
+
+    <script>
+        mocha.setup('bdd');
+        mocha.traceIgnores = ['mocha.min.js', 'chai.min.js'];
+        expect = chai.expect;
+    </script>
+    <div id="container" tabindex="0"></div>
+
+    <script src="../dist/index.js"></script>
+    <script>
+        // 请把 key 写在这里
+        const JSAPIKey = '';
+        const chai = window.chai;
+        const mocha = window.mocha;
+        mocha.setup({
+            timeout: '5000',
+            ui: 'bdd',
+        });
+        const expect = chai.expect;
+        describe('JSAPI', () => {
+            beforeEach(function () {
+                AMapLoader.reset()
+            });
+
+            it('Simple', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '2.0',
+                    plugins: ['AMap.Scale'],
+                    AMapUI: {
+                        plugins: ['overlay/SimpleMarker']
+                    }
+                }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true)
+                    expect(Boolean(window.AMapUI)).eq(true)
+                    expect(Boolean(window.AMapUI.SimpleMarker)).eq(true)
+                    expect(Boolean(window.Loca)).eq(false)
+                    done();
+                });
+
+            });
+            it('Request with AMapUI Loca', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                    plugins: ['AMap.Scale'],
+                    AMapUI: {
+                        plugins: ['overlay/SimpleMarker']
+                    },
+                    Loca: {
+                        version: '1.3.2'
+                    }
+                }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true)
+                    expect(Boolean(window.AMapUI)).eq(true)
+                    expect(Boolean(window.AMapUI.SimpleMarker)).eq(true)
+
+                    expect(Boolean(window.Loca)).eq(true)
+                    done();
+                });
+
+            });
+            it('fail with multi version', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '2.0',
+                }).then(() => {
+                    done()
+                });
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                }).then(() => {
+                    done(Error('should not here'))
+                })
+                    .catch(err => {
+                        try {
+                            expect(err).eq('不允许多个版本 JSAPI 混用')
+
+                        } catch (error) {
+                            done(error)
+                        }
+                    })
+
+            });
+            it('fail with multi key', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '2.0',
+                }).then(() => {
+                    done()
+                });
+                AMapLoader.load({
+                    key: 'asdfas',//首次load必填
+                }).then(() => {
+                    done(Error('should not here'))
+                })
+                    .catch(err => {
+                        try {
+                            expect(err).eq('多个不一致的 key')
+
+                        } catch (error) {
+                            done(error)
+                        }
+                    })
+
+            });
+        })
+
+
+        describe('AMapUI', () => {
+            beforeEach(function () {
+                AMapLoader.reset()
+            });
+
+            it('version', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                    AMapUI: {
+                        version: '1.1',
+                        plugins: ['misc/PathSimplifier']
+                    }
+                }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true)
+                    expect(Boolean(window.AMapUI)).eq(true)
+                    expect(Boolean(window.AMapUI.PathSimplifier)).eq(true)
+                    expect(Boolean(window.AMapUI.version.startsWith('1.1'))).eq(true)
+                    done();
+                }).catch(done);
+            });
+
+            it('async', (done) => {
+                console.log(window.AMap);
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                    AMapUI: {
+                        version: '1.0',
+                        plugins: ['overlay/SimpleMarker']
+                    }
+                }).then(() => {
+                    AMapLoader.load({
+                        AMapUI: {
+                            plugins: ['overlay/SimpleInfoWindow']
+                        }
+                    }).then(() => {
+                        expect(Boolean(window.AMap)).eq(true)
+                        expect(Boolean(window.AMapUI.version.startsWith('1.0'))).eq(true)
+                        expect(Boolean(window.AMapUI.SimpleMarker)).eq(true)
+                        expect(Boolean(window.AMapUI.SimpleInfoWindow)).eq(true)
+                        done()
+                    });
+                }).catch(done);
+            })
+        });
+
+        describe('Loca', () => {
+            beforeEach(function () {
+                AMapLoader.reset()
+            });
+
+            it('version', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                    Loca: {
+                        version: '1.3.1'
+                    }
+                }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true)
+                    expect(Boolean(window.Loca)).eq(true)
+                    expect(window.Loca.version).eq('1.3.1')
+                    done()
+                }).catch(done);
+            });
+            it('fail with jsapi2.0', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '2.0',
+                    Loca: {
+                        version: '1.3.1'
+                    }
+                }).then(() => {
+                    done(Error('should not here'))
+                }).catch(err => {
+                    try {
+                        expect(err).eq("Loca 暂不适配 JSAPI 2.0,请使用 1.4.15")
+                        done()
+                    } catch (error) {
+                        done(error)
+                    }
+                });
+            });
+
+
+            it('async', (done) => {
+                AMapLoader.load({
+                    key: JSAPIKey,//首次load必填
+                    version: '1.4.15',
+                    Loca: {
+                        version: '1.2.1'
+                    }
+                }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true)
+                    expect(Boolean(window.Loca)).eq(true)
+                    expect(window.Loca.version).eq('1.2.1')
+                    AMapLoader.load({
+                        Loca: {
+                            version: '1.2.1'
+                        }
+                    }).then(() => {
+                        expect(Boolean(window.AMap)).eq(true)
+                        expect(Boolean(window.Loca)).eq(true)
+                        expect(window.Loca.version).eq('1.2.1')
+                        done()
+                    }).catch(done);
+
+                });
+            })
+        });
+
+
+        describe('Advance', () => {
+            beforeEach(function () {
+                AMapLoader.reset()
+            });
+            it('Multi', (done) => {
+                AMapLoader.load({ key: JSAPIKey, version: '1.4.15' }).then(() => {
+                    expect(Boolean(window.AMap)).eq(true);
+                    expect(window.AMap.v).eq('1.4.15');
+
+                    expect(Boolean(window.AMapUI)).eq(false);
+                    expect(Boolean(window.Loca)).eq(false);
+                    AMapLoader.load({ AMapUI: {} }).then(() => {
+                        expect(Boolean(window.AMap)).eq(true);
+                        expect(window.AMap.v).eq('1.4.15');
+
+                        expect(Boolean(window.AMapUI)).eq(true);
+                        expect(window.AMapUI.version.startsWith('1.1')).eq(true);
+                        expect(Boolean(window.Loca)).eq(false);
+                        AMapLoader.load({ Loca: {} }).then(() => {
+                            expect(Boolean(window.AMap)).eq(true);
+                            expect(window.AMap.v).eq('1.4.15');
+                            expect(Boolean(window.AMapUI)).eq(true);
+                            expect(window.AMapUI.version.startsWith('1.1')).eq(true);
+                            expect(Boolean(window.Loca)).eq(true);
+                            expect(window.Loca.version).eq('1.3.2');
+                            done()
+                        })
+                    })
+                }).catch(done)
+            })
+        })
+        mocha.run()
+    </script>
+
+
+    </script>
+</body>
+
+</html>

node_modules/@amap/amap-jsapi-loader/index.d.ts

@@ -0,0 +1,15 @@
+declare var load: (options: {
+    key: string; // 申请好的Web端开发者Key，首次调用 load 时必填
+    version: string; // 指定要加载的 JSAPI 的版本，缺省时默认为 1.4.15
+    plugins?: string[]; //插件列表
+    // 是否加载 AMapUI，缺省不加载
+    AMapUI?: {
+        version?: string; // AMapUI 缺省 1.1
+        plugins?: string[]; // 需要加载的 AMapUI ui插件
+    };
+    // 是否加载 Loca， 缺省不加载
+    Loca?: {
+        version?: string; // Loca 版本，缺省 1.3.2
+    };
+}) => Promise<any>;
+export { load };

node_modules/@amap/amap-jsapi-loader/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@amap/amap-jsapi-loader",
+  "version": "1.0.1",
+  "description": "高德官网提供的地图JSAPI加载器，可以避免多种异步加载API的错误用法",
+  "main": "dist/index.js",
+  "types": "index.d.ts",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "build": "rollup -c rollup.config.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@gitlab.alibaba-inc.com:amap-web/amap-jsapi-loader.git"
+  },
+  "keywords": [
+    "amap",
+    "jsapi",
+    "sdk",
+    "loader",
+    "地图",
+    "高德"
+  ],
+  "author": "mengmeng.du@alibaba-inc.com",
+  "license": "MIT",
+  "devDependencies": {
+    "@ampproject/rollup-plugin-closure-compiler": "^0.23.0",
+    "@babel/core": "^7.8.7",
+    "@babel/preset-env": "^7.8.7",
+    "rollup": "^1.32.0",
+    "rollup-plugin-babel": "^4.3.3",
+    "rollup-plugin-server": "^0.7.0",
+    "rollup-plugin-typescript2": "^0.27.1",
+    "typescript": "^3.9.7"
+  }
+}

node_modules/@amap/amap-jsapi-loader/rollup.config.js

@@ -0,0 +1,25 @@
+import server from "rollup-plugin-server";
+import babel from "rollup-plugin-babel";
+import compiler from "@ampproject/rollup-plugin-closure-compiler";
+import rollupTypescript from 'rollup-plugin-typescript2';
+
+export default {
+    input: "src/index.ts",
+    output: {
+        file: "dist/index.js",
+        format: "umd",
+        name: "AMapLoader",
+    },
+    plugins: [
+        rollupTypescript(),
+        babel({
+            presets: [["@babel/env", { targets: { ie: 9 } }]],
+        }),
+        compiler(),
+        server({
+            contentBase: "./",
+            host: "127.0.0.1",
+            port: 3601,
+        }),
+    ],
+};

node_modules/@amap/amap-jsapi-loader/src/global.d.ts

@@ -0,0 +1,5 @@
+declare var AMap: any;
+declare var AMapUI: any;
+declare var Loca: any;
+
+declare var ___onAPILoaded: any;

node_modules/@amap/amap-jsapi-loader/src/index.ts

@@ -0,0 +1,367 @@
+if (!window) {
+    throw Error("AMap JSAPI can only be used in Browser.");
+}
+enum LoadStatus {
+    notload = "notload",
+    loading = "loading",
+    loaded = "loaded",
+    failed = "failed",
+}
+let config = {
+    key: "",
+    AMap: {
+        version: "1.4.15",
+        plugins: [],
+    },
+    AMapUI: {
+        version: "1.1",
+        plugins: [],
+    },
+    Loca: {
+        version: "1.3.2",
+    },
+};
+
+let Status = {
+    AMap: LoadStatus.notload,
+    AMapUI: LoadStatus.notload,
+    Loca: LoadStatus.notload,
+};
+let Callback = {
+    AMap: [],
+    AMapUI: [],
+    Loca: [],
+};
+
+let onloadCBKs = [];
+const onload = function (callback) {
+    if (typeof callback == "function") {
+        if (Status.AMap === LoadStatus.loaded) {
+            callback(window.AMap);
+            return;
+        }
+        onloadCBKs.push(callback);
+    }
+};
+
+interface LoadOption {
+    key: string;
+    version?: string;
+    plugins?: string[];
+    AMapUI?: {
+        version?: string;
+        plugins?: string[];
+    };
+    Loca?: {
+        version?: string;
+    };
+}
+function appendOther(option: LoadOption): Promise<any> {
+    let pros: Promise<void>[] = [];
+    if (option.AMapUI) {
+        pros.push(loadAMapUI(option.AMapUI));
+    }
+    if (option.Loca) {
+        pros.push(loadLoca(option.Loca));
+    }
+    return Promise.all(pros);
+}
+function loadAMapUI(params: { version?: string; plugins?: string[] }): Promise<void> {
+    return new Promise((res, rej) => {
+        const newPlugins: string[] = [];
+        if (params.plugins) {
+            for (var i = 0; i < params.plugins.length; i += 1) {
+                if (config.AMapUI.plugins.indexOf(params.plugins[i]) == -1) {
+                    newPlugins.push(params.plugins[i]);
+                }
+            }
+        }
+        if (Status.AMapUI === LoadStatus.failed) {
+            rej("前次请求 AMapUI 失败");
+        } else if (Status.AMapUI === LoadStatus.notload) {
+            Status.AMapUI = LoadStatus.loading;
+            config.AMapUI.version = params.version || config.AMapUI.version;
+            const version = config.AMapUI.version;
+            const parentNode = document.body || document.head;
+            const script = document.createElement("script");
+            script.type = "text/javascript";
+            script.src = `https://webapi.amap.com/ui/${version}/main.js`;
+
+            script.onerror = (e) => {
+                Status.AMapUI = LoadStatus.failed;
+                rej("请求 AMapUI 失败");
+            };
+            script.onload = () => {
+                Status.AMapUI = LoadStatus.loaded;
+                if (newPlugins.length) {
+                    window.AMapUI.loadUI(newPlugins, function () {
+                        for (let i = 0, len = newPlugins.length; i < len; i++) {
+                            const path = newPlugins[i];
+                            const name = path.split("/").slice(-1)[0];
+                            window.AMapUI[name] = arguments[i];
+                        }
+                        res();
+                        while (Callback.AMapUI.length) {
+                            Callback.AMapUI.splice(0, 1)[0]();
+                        }
+                    });
+                } else {
+                    res();
+                    while (Callback.AMapUI.length) {
+                        Callback.AMapUI.splice(0, 1)[0]();
+                    }
+                }
+            };
+            parentNode.appendChild(script);
+        } else if (Status.AMapUI === LoadStatus.loaded) {
+            if (params.version && params.version !== config.AMapUI.version) {
+                rej("不允许多个版本 AMapUI 混用");
+            } else {
+                if (newPlugins.length) {
+                    window.AMapUI.loadUI(newPlugins, function () {
+                        for (let i = 0, len = newPlugins.length; i < len; i++) {
+                            const path = newPlugins[i];
+                            const name = path.split("/").slice(-1)[0];
+                            window.AMapUI[name] = arguments[i];
+                        }
+                        res();
+                    });
+                } else {
+                    res();
+                }
+            }
+        } else {
+            if (params.version && params.version !== config.AMapUI.version) {
+                rej("不允许多个版本 AMapUI 混用");
+            } else {
+                Callback.AMapUI.push((err) => {
+                    if (err) {
+                        rej(err);
+                    } else {
+                        if (newPlugins.length) {
+                            window.AMapUI.loadUI(newPlugins, function () {
+                                for (let i = 0, len = newPlugins.length; i < len; i++) {
+                                    const path = newPlugins[i];
+                                    const name = path.split("/").slice(-1)[0];
+                                    window.AMapUI[name] = arguments[i];
+                                }
+                                res();
+                            });
+                        } else {
+                            res();
+                        }
+                    }
+                });
+            }
+        }
+    });
+}
+
+function loadLoca(params: { version?: string }): Promise<void> {
+    return new Promise((res, rej) => {
+        if (Status.Loca === LoadStatus.failed) {
+            rej("前次请求 Loca 失败");
+        } else if (Status.Loca === LoadStatus.notload) {
+            Status.Loca = LoadStatus.loading;
+            config.Loca.version = params.version || config.Loca.version;
+            const version = config.Loca.version;
+            const isApiV2 = config.AMap.version.startsWith("2");
+            const isLocaV2 = version.startsWith("2");
+            if ((isApiV2 && !isLocaV2) || (!isApiV2 && isLocaV2)) {
+                rej("JSAPI 与 Loca 版本不对应！！");
+                return;
+            }
+            const key = config.key;
+            const parentNode = document.body || document.head;
+            const script = document.createElement("script");
+            script.type = "text/javascript";
+            script.src = `https://webapi.amap.com/loca?v=${version}&key=${key}`;
+
+            script.onerror = (e) => {
+                Status.Loca = LoadStatus.failed;
+                rej("请求 AMapUI 失败");
+            };
+            script.onload = () => {
+                Status.Loca = LoadStatus.loaded;
+                res();
+                while (Callback.Loca.length) {
+                    Callback.Loca.splice(0, 1)[0]();
+                }
+            };
+            parentNode.appendChild(script);
+        } else if (Status.Loca === LoadStatus.loaded) {
+            if (params.version && params.version !== config.Loca.version) {
+                rej("不允许多个版本 Loca 混用");
+            } else {
+                res();
+            }
+        } else {
+            if (params.version && params.version !== config.Loca.version) {
+                rej("不允许多个版本 Loca 混用");
+            } else {
+                Callback.Loca.push((err) => {
+                    if (err) {
+                        rej(err);
+                    } else {
+                        rej();
+                    }
+                });
+            }
+        }
+    });
+}
+
+const load = function (options: LoadOption) {
+    return new Promise((resolve, reject) => {
+        if (Status.AMap == LoadStatus.failed) {
+            reject("");
+        } else if (Status.AMap == LoadStatus.notload) {
+            //初次加载
+            let { key, version, plugins } = options;
+            if (!key) {
+                reject("请填写key");
+                return;
+            }
+            if (window.AMap && location.host !== "lbs.amap.com") {
+                reject("禁止多种API加载方式混用");
+            }
+            config.key = key;
+            config.AMap.version = version || config.AMap.version;
+            config.AMap.plugins = plugins || config.AMap.plugins;
+            Status.AMap = LoadStatus.loading;
+
+            const parentNode = document.body || document.head;
+
+            window.___onAPILoaded = function (err) {
+                delete window.___onAPILoaded;
+                if (err) {
+                    Status.AMap = LoadStatus.failed;
+                    reject(err);
+                } else {
+                    Status.AMap = LoadStatus.loaded;
+                    appendOther(options)
+                        .then(() => {
+                            resolve(window.AMap);
+                        })
+                        .catch(reject);
+                    while (onloadCBKs.length) {
+                        onloadCBKs.splice(0, 1)[0]();
+                    }
+                }
+            };
+            const script = document.createElement("script");
+            script.type = "text/javascript";
+
+            script.src =
+                "https://webapi.amap.com/maps?callback=___onAPILoaded&v=" +
+                config.AMap.version +
+                "&key=" +
+                key +
+                "&plugin=" +
+                config.AMap.plugins.join(",");
+            script.onerror = (e) => {
+                Status.AMap = LoadStatus.failed;
+                reject(e);
+            };
+            parentNode.appendChild(script);
+        } else if (Status.AMap == LoadStatus.loaded) {
+            //deal multi load
+            if (options.key && options.key !== config.key) {
+                reject("多个不一致的 key");
+                return;
+            }
+            if (options.version && options.version !== config.AMap.version) {
+                reject("不允许多个版本 JSAPI 混用");
+                return;
+            }
+            const newPlugins = [];
+            if (options.plugins) {
+                for (var i = 0; i < options.plugins.length; i += 1) {
+                    if (config.AMap.plugins.indexOf(options.plugins[i]) == -1) {
+                        newPlugins.push(options.plugins[i]);
+                    }
+                }
+            }
+            if (newPlugins.length) {
+                window.AMap.plugin(newPlugins, () => {
+                    appendOther(options)
+                        .then(() => {
+                            resolve(window.AMap);
+                        })
+                        .catch(reject);
+                });
+            } else {
+                appendOther(options)
+                    .then(() => {
+                        resolve(window.AMap);
+                    })
+                    .catch(reject);
+            }
+        } else {
+            // loading
+            if (options.key && options.key !== config.key) {
+                reject("多个不一致的 key");
+                return;
+            }
+            if (options.version && options.version !== config.AMap.version) {
+                reject("不允许多个版本 JSAPI 混用");
+                return;
+            }
+            const newPlugins = [];
+            if (options.plugins) {
+                for (var i = 0; i < options.plugins.length; i += 1) {
+                    if (config.AMap.plugins.indexOf(options.plugins[i]) == -1) {
+                        newPlugins.push(options.plugins[i]);
+                    }
+                }
+            }
+            onload(() => {
+                if (newPlugins.length) {
+                    window.AMap.plugin(newPlugins, () => {
+                        appendOther(options)
+                            .then(() => {
+                                resolve(window.AMap);
+                            })
+                            .catch(reject);
+                    });
+                } else {
+                    appendOther(options)
+                        .then(() => {
+                            resolve(window.AMap);
+                        })
+                        .catch(reject);
+                }
+            });
+        }
+    });
+};
+function reset() {
+    delete window.AMap;
+    delete window.AMapUI;
+    delete window.Loca;
+    config = {
+        key: "",
+        AMap: {
+            version: "1.4.15",
+            plugins: [],
+        },
+        AMapUI: {
+            version: "1.1",
+            plugins: [],
+        },
+        Loca: {
+            version: "1.3.2",
+        },
+    };
+    Status = {
+        AMap: LoadStatus.notload,
+        AMapUI: LoadStatus.notload,
+        Loca: LoadStatus.notload,
+    };
+    Callback = {
+        AMap: [],
+        AMapUI: [],
+        Loca: [],
+    };
+}
+export default { load, reset };

node_modules/@amap/amap-jsapi-loader/test/demo.ts

@@ -0,0 +1,17 @@
+import AMapLoader from "../";
+// import {  } from "@ali/test-amap-jsapi";
+
+AMapLoader.load({
+  key: "test",
+  version: "2.0"
+}).then(() => {
+  new AMap.Circle({})
+  const map = new AMap.Map("div");
+  map.on("complete", () => {
+    const circle = new AMap.Circle({
+      center: [135, 45],
+      radius: 40
+    });
+    map.add(circle);
+  });
+});

node_modules/@amap/amap-jsapi-loader/test/test.ts

@@ -0,0 +1,7 @@
+import AMapLoader from "../";
+import "@amap/amap-jsapi-loader";
+
+AMapLoader.load({
+  key: "test",
+  version: "2.0"
+}).then(() => {});

node_modules/@angular/animations/LICENSE

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

node_modules/@angular/animations/README.md

@@ -0,0 +1,8 @@
+Angular
+=======
+
+The sources for this package are in the main [Angular](https://github.com/angular/angular) repo. Please file issues and pull requests against that repo.
+
+Usage information and reference details can be found in [Angular documentation](https://angular.dev/overview).
+
+License: MIT

node_modules/@angular/animations/animation_driver.d-DAiEDqQt.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @license Angular v19.2.13
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import * as i0 from '@angular/core';
+import { AnimationPlayer } from './animation_player.d-Dv9iW4uh.js';
+
+/**
+ * @publicApi
+ *
+ * `AnimationDriver` implentation for Noop animations
+ */
+declare class NoopAnimationDriver implements AnimationDriver {
+    /**
+     * @returns Whether `prop` is a valid CSS property
+     */
+    validateStyleProperty(prop: string): boolean;
+    /**
+     *
+     * @returns Whether elm1 contains elm2.
+     */
+    containsElement(elm1: any, elm2: any): boolean;
+    /**
+     * @returns Rhe parent of the given element or `null` if the element is the `document`
+     */
+    getParentElement(element: unknown): unknown;
+    /**
+     * @returns The result of the query selector on the element. The array will contain up to 1 item
+     *     if `multi` is  `false`.
+     */
+    query(element: any, selector: string, multi: boolean): any[];
+    /**
+     * @returns The `defaultValue` or empty string
+     */
+    computeStyle(element: any, prop: string, defaultValue?: string): string;
+    /**
+     * @returns An `NoopAnimationPlayer`
+     */
+    animate(element: any, keyframes: Array<Map<string, string | number>>, duration: number, delay: number, easing: string, previousPlayers?: any[], scrubberAccessRequested?: boolean): AnimationPlayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoopAnimationDriver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NoopAnimationDriver>;
+}
+/**
+ * @publicApi
+ */
+declare abstract class AnimationDriver {
+    /**
+     * @deprecated Use the NoopAnimationDriver class.
+     */
+    static NOOP: AnimationDriver;
+    abstract validateStyleProperty(prop: string): boolean;
+    abstract validateAnimatableStyleProperty?: (prop: string) => boolean;
+    abstract containsElement(elm1: any, elm2: any): boolean;
+    /**
+     * Obtains the parent element, if any. `null` is returned if the element does not have a parent.
+     */
+    abstract getParentElement(element: unknown): unknown;
+    abstract query(element: any, selector: string, multi: boolean): any[];
+    abstract computeStyle(element: any, prop: string, defaultValue?: string): string;
+    abstract animate(element: any, keyframes: Array<Map<string, string | number>>, duration: number, delay: number, easing?: string | null, previousPlayers?: any[], scrubberAccessRequested?: boolean): any;
+}
+
+export { AnimationDriver, NoopAnimationDriver };

node_modules/@angular/animations/animation_player.d-Dv9iW4uh.d.ts

@@ -0,0 +1,1407 @@
+/**
+ * @license Angular v19.2.13
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+/**
+ * Represents a set of CSS styles for use in an animation style as a generic.
+ */
+interface ɵStyleData {
+    [key: string]: string | number;
+}
+/**
+ * Represents a set of CSS styles for use in an animation style as a Map.
+ */
+type ɵStyleDataMap = Map<string, string | number>;
+/**
+ * Represents animation-step timing parameters for an animation step.
+ * @see {@link animate}
+ *
+ * @publicApi
+ */
+declare type AnimateTimings = {
+    /**
+     * The full duration of an animation step. A number and optional time unit,
+     * such as "1s" or "10ms" for one second and 10 milliseconds, respectively.
+     * The default unit is milliseconds.
+     */
+    duration: number;
+    /**
+     * The delay in applying an animation step. A number and optional time unit.
+     * The default unit is milliseconds.
+     */
+    delay: number;
+    /**
+     * An easing style that controls how an animations step accelerates
+     * and decelerates during its run time. An easing function such as `cubic-bezier()`,
+     * or one of the following constants:
+     * - `ease-in`
+     * - `ease-out`
+     * - `ease-in-and-out`
+     */
+    easing: string | null;
+};
+/**
+ * @description Options that control animation styling and timing.
+ *
+ * The following animation functions accept `AnimationOptions` data:
+ *
+ * - `transition()`
+ * - `sequence()`
+ * - `group()`
+ * - `query()`
+ * - `animation()`
+ * - `useAnimation()`
+ * - `animateChild()`
+ *
+ * Programmatic animations built using the `AnimationBuilder` service also
+ * make use of `AnimationOptions`.
+ *
+ * @publicApi
+ */
+declare interface AnimationOptions {
+    /**
+     * Sets a time-delay for initiating an animation action.
+     * A number and optional time unit, such as "1s" or "10ms" for one second
+     * and 10 milliseconds, respectively.The default unit is milliseconds.
+     * Default value is 0, meaning no delay.
+     */
+    delay?: number | string;
+    /**
+     * A set of developer-defined parameters that modify styling and timing
+     * when an animation action starts. An array of key-value pairs, where the provided value
+     * is used as a default.
+     */
+    params?: {
+        [name: string]: any;
+    };
+}
+/**
+ * Adds duration options to control animation styling and timing for a child animation.
+ *
+ * @see {@link animateChild}
+ *
+ * @publicApi
+ */
+declare interface AnimateChildOptions extends AnimationOptions {
+    duration?: number | string;
+}
+/**
+ * @description Constants for the categories of parameters that can be defined for animations.
+ *
+ * A corresponding function defines a set of parameters for each category, and
+ * collects them into a corresponding `AnimationMetadata` object.
+ *
+ * @publicApi
+ */
+declare enum AnimationMetadataType {
+    /**
+     * Associates a named animation state with a set of CSS styles.
+     * See [`state()`](api/animations/state)
+     */
+    State = 0,
+    /**
+     * Data for a transition from one animation state to another.
+     * See `transition()`
+     */
+    Transition = 1,
+    /**
+     * Contains a set of animation steps.
+     * See `sequence()`
+     */
+    Sequence = 2,
+    /**
+     * Contains a set of animation steps.
+     * See `group()`
+     */
+    Group = 3,
+    /**
+     * Contains an animation step.
+     * See `animate()`
+     */
+    Animate = 4,
+    /**
+     * Contains a set of animation steps.
+     * See `keyframes()`
+     */
+    Keyframes = 5,
+    /**
+     * Contains a set of CSS property-value pairs into a named style.
+     * See `style()`
+     */
+    Style = 6,
+    /**
+     * Associates an animation with an entry trigger that can be attached to an element.
+     * See `trigger()`
+     */
+    Trigger = 7,
+    /**
+     * Contains a re-usable animation.
+     * See `animation()`
+     */
+    Reference = 8,
+    /**
+     * Contains data to use in executing child animations returned by a query.
+     * See `animateChild()`
+     */
+    AnimateChild = 9,
+    /**
+     * Contains animation parameters for a re-usable animation.
+     * See `useAnimation()`
+     */
+    AnimateRef = 10,
+    /**
+     * Contains child-animation query data.
+     * See `query()`
+     */
+    Query = 11,
+    /**
+     * Contains data for staggering an animation sequence.
+     * See `stagger()`
+     */
+    Stagger = 12
+}
+/**
+ * Specifies automatic styling.
+ *
+ * @publicApi
+ */
+declare const AUTO_STYLE = "*";
+/**
+ * Base for animation data structures.
+ *
+ * @publicApi
+ */
+interface AnimationMetadata {
+    type: AnimationMetadataType;
+}
+/**
+ * Contains an animation trigger. Instantiated and returned by the
+ * `trigger()` function.
+ *
+ * @publicApi
+ */
+interface AnimationTriggerMetadata extends AnimationMetadata {
+    /**
+     * The trigger name, used to associate it with an element. Unique within the component.
+     */
+    name: string;
+    /**
+     * An animation definition object, containing an array of state and transition declarations.
+     */
+    definitions: AnimationMetadata[];
+    /**
+     * An options object containing a delay and
+     * developer-defined parameters that provide styling defaults and
+     * can be overridden on invocation. Default delay is 0.
+     */
+    options: {
+        params?: {
+            [name: string]: any;
+        };
+    } | null;
+}
+/**
+ * Encapsulates an animation state by associating a state name with a set of CSS styles.
+ * Instantiated and returned by the [`state()`](api/animations/state) function.
+ *
+ * @publicApi
+ */
+interface AnimationStateMetadata extends AnimationMetadata {
+    /**
+     * The state name, unique within the component.
+     */
+    name: string;
+    /**
+     *  The CSS styles associated with this state.
+     */
+    styles: AnimationStyleMetadata;
+    /**
+     * An options object containing
+     * developer-defined parameters that provide styling defaults and
+     * can be overridden on invocation.
+     */
+    options?: {
+        params: {
+            [name: string]: any;
+        };
+    };
+}
+/**
+ * Encapsulates an animation transition. Instantiated and returned by the
+ * `transition()` function.
+ *
+ * @publicApi
+ */
+interface AnimationTransitionMetadata extends AnimationMetadata {
+    /**
+     * An expression that describes a state change.
+     */
+    expr: string | ((fromState: string, toState: string, element?: any, params?: {
+        [key: string]: any;
+    }) => boolean);
+    /**
+     * One or more animation objects to which this transition applies.
+     */
+    animation: AnimationMetadata | AnimationMetadata[];
+    /**
+     * An options object containing a delay and
+     * developer-defined parameters that provide styling defaults and
+     * can be overridden on invocation. Default delay is 0.
+     */
+    options: AnimationOptions | null;
+}
+/**
+ * Encapsulates a reusable animation, which is a collection of individual animation steps.
+ * Instantiated and returned by the `animation()` function, and
+ * passed to the `useAnimation()` function.
+ *
+ * @publicApi
+ */
+interface AnimationReferenceMetadata extends AnimationMetadata {
+    /**
+     *  One or more animation step objects.
+     */
+    animation: AnimationMetadata | AnimationMetadata[];
+    /**
+     * An options object containing a delay and
+     * developer-defined parameters that provide styling defaults and
+     * can be overridden on invocation. Default delay is 0.
+     */
+    options: AnimationOptions | null;
+}
+/**
+ * Encapsulates an animation query. Instantiated and returned by
+ * the `query()` function.
+ *
+ * @publicApi
+ */
+interface AnimationQueryMetadata extends AnimationMetadata {
+    /**
+     *  The CSS selector for this query.
+     */
+    selector: string;
+    /**
+     * One or more animation step objects.
+     */
+    animation: AnimationMetadata | AnimationMetadata[];
+    /**
+     * A query options object.
+     */
+    options: AnimationQueryOptions | null;
+}
+/**
+ * Encapsulates a keyframes sequence. Instantiated and returned by
+ * the `keyframes()` function.
+ *
+ * @publicApi
+ */
+interface AnimationKeyframesSequenceMetadata extends AnimationMetadata {
+    /**
+     * An array of animation styles.
+     */
+    steps: AnimationStyleMetadata[];
+}
+/**
+ * Encapsulates an animation style. Instantiated and returned by
+ * the `style()` function.
+ *
+ * @publicApi
+ */
+interface AnimationStyleMetadata extends AnimationMetadata {
+    /**
+     * A set of CSS style properties.
+     */
+    styles: '*' | {
+        [key: string]: string | number;
+    } | Array<{
+        [key: string]: string | number;
+    } | '*'>;
+    /**
+     * A percentage of the total animate time at which the style is to be applied.
+     */
+    offset: number | null;
+}
+/**
+ * Encapsulates an animation step. Instantiated and returned by
+ * the `animate()` function.
+ *
+ * @publicApi
+ */
+interface AnimationAnimateMetadata extends AnimationMetadata {
+    /**
+     * The timing data for the step.
+     */
+    timings: string | number | AnimateTimings;
+    /**
+     * A set of styles used in the step.
+     */
+    styles: AnimationStyleMetadata | AnimationKeyframesSequenceMetadata | null;
+}
+/**
+ * Encapsulates a child animation, that can be run explicitly when the parent is run.
+ * Instantiated and returned by the `animateChild` function.
+ *
+ * @publicApi
+ */
+interface AnimationAnimateChildMetadata extends AnimationMetadata {
+    /**
+     * An options object containing a delay and
+     * developer-defined parameters that provide styling defaults and
+     * can be overridden on invocation. Default delay is 0.
+     */
+    options: AnimationOptions | null;
+}
+/**
+ * Encapsulates a reusable animation.
+ * Instantiated and returned by the `useAnimation()` function.
+ *
+ * @publicApi
+ */
+interface AnimationAnimateRefMetadata extends AnimationMetadata {
+    /**
+     * An animation reference object.
+     */
+    animation: AnimationReferenceMetadata;
+    /**
+     * An options object containing a delay and
+     * developer-defined parameters that provide styling defaults and
+     * can be overridden on invocation. Default delay is 0.
+     */
+    options: AnimationOptions | null;
+}
+/**
+ * Encapsulates an animation sequence.
+ * Instantiated and returned by the `sequence()` function.
+ *
+ * @publicApi
+ */
+interface AnimationSequenceMetadata extends AnimationMetadata {
+    /**
+     *  An array of animation step objects.
+     */
+    steps: AnimationMetadata[];
+    /**
+     * An options object containing a delay and
+     * developer-defined parameters that provide styling defaults and
+     * can be overridden on invocation. Default delay is 0.
+     */
+    options: AnimationOptions | null;
+}
+/**
+ * Encapsulates an animation group.
+ * Instantiated and returned by the `group()` function.
+ *
+ * @publicApi
+ */
+interface AnimationGroupMetadata extends AnimationMetadata {
+    /**
+     * One or more animation or style steps that form this group.
+     */
+    steps: AnimationMetadata[];
+    /**
+     * An options object containing a delay and
+     * developer-defined parameters that provide styling defaults and
+     * can be overridden on invocation. Default delay is 0.
+     */
+    options: AnimationOptions | null;
+}
+/**
+ * Encapsulates animation query options.
+ * Passed to the `query()` function.
+ *
+ * @publicApi
+ */
+declare interface AnimationQueryOptions extends AnimationOptions {
+    /**
+     * True if this query is optional, false if it is required. Default is false.
+     * A required query throws an error if no elements are retrieved when
+     * the query is executed. An optional query does not.
+     *
+     */
+    optional?: boolean;
+    /**
+     * A maximum total number of results to return from the query.
+     * If negative, results are limited from the end of the query list towards the beginning.
+     * By default, results are not limited.
+     */
+    limit?: number;
+}
+/**
+ * Encapsulates parameters for staggering the start times of a set of animation steps.
+ * Instantiated and returned by the `stagger()` function.
+ *
+ * @publicApi
+ **/
+interface AnimationStaggerMetadata extends AnimationMetadata {
+    /**
+     * The timing data for the steps.
+     */
+    timings: string | number;
+    /**
+     * One or more animation steps.
+     */
+    animation: AnimationMetadata | AnimationMetadata[];
+}
+/**
+ * Creates a named animation trigger, containing a  list of [`state()`](api/animations/state)
+ * and `transition()` entries to be evaluated when the expression
+ * bound to the trigger changes.
+ *
+ * @param name An identifying string.
+ * @param definitions  An animation definition object, containing an array of
+ * [`state()`](api/animations/state) and `transition()` declarations.
+ *
+ * @return An object that encapsulates the trigger data.
+ *
+ * @usageNotes
+ * Define an animation trigger in the `animations` section of `@Component` metadata.
+ * In the template, reference the trigger by name and bind it to a trigger expression that
+ * evaluates to a defined animation state, using the following format:
+ *
+ * `[@triggerName]="expression"`
+ *
+ * Animation trigger bindings convert all values to strings, and then match the
+ * previous and current values against any linked transitions.
+ * Booleans can be specified as `1` or `true` and `0` or `false`.
+ *
+ * ### Usage Example
+ *
+ * The following example creates an animation trigger reference based on the provided
+ * name value.
+ * The provided animation value is expected to be an array consisting of state and
+ * transition declarations.
+ *
+ * ```ts
+ * @Component({
+ *   selector: "my-component",
+ *   templateUrl: "my-component-tpl.html",
+ *   animations: [
+ *     trigger("myAnimationTrigger", [
+ *       state(...),
+ *       state(...),
+ *       transition(...),
+ *       transition(...)
+ *     ])
+ *   ]
+ * })
+ * class MyComponent {
+ *   myStatusExp = "something";
+ * }
+ * ```
+ *
+ * The template associated with this component makes use of the defined trigger
+ * by binding to an element within its template code.
+ *
+ * ```html
+ * <!-- somewhere inside of my-component-tpl.html -->
+ * <div [@myAnimationTrigger]="myStatusExp">...</div>
+ * ```
+ *
+ * ### Using an inline function
+ * The `transition` animation method also supports reading an inline function which can decide
+ * if its associated animation should be run.
+ *
+ * ```ts
+ * // this method is run each time the `myAnimationTrigger` trigger value changes.
+ * function myInlineMatcherFn(fromState: string, toState: string, element: any, params: {[key:
+ string]: any}): boolean {
+ *   // notice that `element` and `params` are also available here
+ *   return toState == 'yes-please-animate';
+ * }
+ *
+ * @Component({
+ *   selector: 'my-component',
+ *   templateUrl: 'my-component-tpl.html',
+ *   animations: [
+ *     trigger('myAnimationTrigger', [
+ *       transition(myInlineMatcherFn, [
+ *         // the animation sequence code
+ *       ]),
+ *     ])
+ *   ]
+ * })
+ * class MyComponent {
+ *   myStatusExp = "yes-please-animate";
+ * }
+ * ```
+ *
+ * ### Disabling Animations
+ * When true, the special animation control binding `@.disabled` binding prevents
+ * all animations from rendering.
+ * Place the  `@.disabled` binding on an element to disable
+ * animations on the element itself, as well as any inner animation triggers
+ * within the element.
+ *
+ * The following example shows how to use this feature:
+ *
+ * ```angular-ts
+ * @Component({
+ *   selector: 'my-component',
+ *   template: `
+ *     <div [@.disabled]="isDisabled">
+ *       <div [@childAnimation]="exp"></div>
+ *     </div>
+ *   `,
+ *   animations: [
+ *     trigger("childAnimation", [
+ *       // ...
+ *     ])
+ *   ]
+ * })
+ * class MyComponent {
+ *   isDisabled = true;
+ *   exp = '...';
+ * }
+ * ```
+ *
+ * When `@.disabled` is true, it prevents the `@childAnimation` trigger from animating,
+ * along with any inner animations.
+ *
+ * ### Disable animations application-wide
+ * When an area of the template is set to have animations disabled,
+ * **all** inner components have their animations disabled as well.
+ * This means that you can disable all animations for an app
+ * by placing a host binding set on `@.disabled` on the topmost Angular component.
+ *
+ * ```ts
+ * import {Component, HostBinding} from '@angular/core';
+ *
+ * @Component({
+ *   selector: 'app-component',
+ *   templateUrl: 'app.component.html',
+ * })
+ * class AppComponent {
+ *   @HostBinding('@.disabled')
+ *   public animationsDisabled = true;
+ * }
+ * ```
+ *
+ * ### Overriding disablement of inner animations
+ * Despite inner animations being disabled, a parent animation can `query()`
+ * for inner elements located in disabled areas of the template and still animate
+ * them if needed. This is also the case for when a sub animation is
+ * queried by a parent and then later animated using `animateChild()`.
+ *
+ * ### Detecting when an animation is disabled
+ * If a region of the DOM (or the entire application) has its animations disabled, the animation
+ * trigger callbacks still fire, but for zero seconds. When the callback fires, it provides
+ * an instance of an `AnimationEvent`. If animations are disabled,
+ * the `.disabled` flag on the event is true.
+ *
+ * @publicApi
+ */
+declare function trigger(name: string, definitions: AnimationMetadata[]): AnimationTriggerMetadata;
+/**
+ * Defines an animation step that combines styling information with timing information.
+ *
+ * @param timings Sets `AnimateTimings` for the parent animation.
+ * A string in the format "duration [delay] [easing]".
+ *  - Duration and delay are expressed as a number and optional time unit,
+ * such as "1s" or "10ms" for one second and 10 milliseconds, respectively.
+ * The default unit is milliseconds.
+ *  - The easing value controls how the animation accelerates and decelerates
+ * during its runtime. Value is one of  `ease`, `ease-in`, `ease-out`,
+ * `ease-in-out`, or a `cubic-bezier()` function call.
+ * If not supplied, no easing is applied.
+ *
+ * For example, the string "1s 100ms ease-out" specifies a duration of
+ * 1000 milliseconds, and delay of 100 ms, and the "ease-out" easing style,
+ * which decelerates near the end of the duration.
+ * @param styles Sets AnimationStyles for the parent animation.
+ * A function call to either `style()` or `keyframes()`
+ * that returns a collection of CSS style entries to be applied to the parent animation.
+ * When null, uses the styles from the destination state.
+ * This is useful when describing an animation step that will complete an animation;
+ * see "Animating to the final state" in `transitions()`.
+ * @returns An object that encapsulates the animation step.
+ *
+ * @usageNotes
+ * Call within an animation `sequence()`, {@link /api/animations/group group()}, or
+ * `transition()` call to specify an animation step
+ * that applies given style data to the parent animation for a given amount of time.
+ *
+ * ### Syntax Examples
+ * **Timing examples**
+ *
+ * The following examples show various `timings` specifications.
+ * - `animate(500)` : Duration is 500 milliseconds.
+ * - `animate("1s")` : Duration is 1000 milliseconds.
+ * - `animate("100ms 0.5s")` : Duration is 100 milliseconds, delay is 500 milliseconds.
+ * - `animate("5s ease-in")` : Duration is 5000 milliseconds, easing in.
+ * - `animate("5s 10ms cubic-bezier(.17,.67,.88,.1)")` : Duration is 5000 milliseconds, delay is 10
+ * milliseconds, easing according to a bezier curve.
+ *
+ * **Style examples**
+ *
+ * The following example calls `style()` to set a single CSS style.
+ * ```ts
+ * animate(500, style({ background: "red" }))
+ * ```
+ * The following example calls `keyframes()` to set a CSS style
+ * to different values for successive keyframes.
+ * ```ts
+ * animate(500, keyframes(
+ *  [
+ *   style({ background: "blue" }),
+ *   style({ background: "red" })
+ *  ])
+ * ```
+ *
+ * @publicApi
+ */
+declare function animate(timings: string | number, styles?: AnimationStyleMetadata | AnimationKeyframesSequenceMetadata | null): AnimationAnimateMetadata;
+/**
+ * @description Defines a list of animation steps to be run in parallel.
+ *
+ * @param steps An array of animation step objects.
+ * - When steps are defined by `style()` or `animate()`
+ * function calls, each call within the group is executed instantly.
+ * - To specify offset styles to be applied at a later time, define steps with
+ * `keyframes()`, or use `animate()` calls with a delay value.
+ * For example:
+ *
+ * ```ts
+ * group([
+ *   animate("1s", style({ background: "black" })),
+ *   animate("2s", style({ color: "white" }))
+ * ])
+ * ```
+ *
+ * @param options An options object containing a delay and
+ * developer-defined parameters that provide styling defaults and
+ * can be overridden on invocation.
+ *
+ * @return An object that encapsulates the group data.
+ *
+ * @usageNotes
+ * Grouped animations are useful when a series of styles must be
+ * animated at different starting times and closed off at different ending times.
+ *
+ * When called within a `sequence()` or a
+ * `transition()` call, does not continue to the next
+ * instruction until all of the inner animation steps have completed.
+ *
+ * @publicApi
+ */
+declare function group(steps: AnimationMetadata[], options?: AnimationOptions | null): AnimationGroupMetadata;
+/**
+ * Defines a list of animation steps to be run sequentially, one by one.
+ *
+ * @param steps An array of animation step objects.
+ * - Steps defined by `style()` calls apply the styling data immediately.
+ * - Steps defined by `animate()` calls apply the styling data over time
+ *   as specified by the timing data.
+ *
+ * ```ts
+ * sequence([
+ *   style({ opacity: 0 }),
+ *   animate("1s", style({ opacity: 1 }))
+ * ])
+ * ```
+ *
+ * @param options An options object containing a delay and
+ * developer-defined parameters that provide styling defaults and
+ * can be overridden on invocation.
+ *
+ * @return An object that encapsulates the sequence data.
+ *
+ * @usageNotes
+ * When you pass an array of steps to a
+ * `transition()` call, the steps run sequentially by default.
+ * Compare this to the  {@link /api/animations/group group()} call, which runs animation steps in
+ *parallel.
+ *
+ * When a sequence is used within a  {@link /api/animations/group group()} or a `transition()` call,
+ * execution continues to the next instruction only after each of the inner animation
+ * steps have completed.
+ *
+ * @publicApi
+ **/
+declare function sequence(steps: AnimationMetadata[], options?: AnimationOptions | null): AnimationSequenceMetadata;
+/**
+ * Declares a key/value object containing CSS properties/styles that
+ * can then be used for an animation [`state`](api/animations/state), within an animation
+ *`sequence`, or as styling data for calls to `animate()` and `keyframes()`.
+ *
+ * @param tokens A set of CSS styles or HTML styles associated with an animation state.
+ * The value can be any of the following:
+ * - A key-value style pair associating a CSS property with a value.
+ * - An array of key-value style pairs.
+ * - An asterisk (*), to use auto-styling, where styles are derived from the element
+ * being animated and applied to the animation when it starts.
+ *
+ * Auto-styling can be used to define a state that depends on layout or other
+ * environmental factors.
+ *
+ * @return An object that encapsulates the style data.
+ *
+ * @usageNotes
+ * The following examples create animation styles that collect a set of
+ * CSS property values:
+ *
+ * ```ts
+ * // string values for CSS properties
+ * style({ background: "red", color: "blue" })
+ *
+ * // numerical pixel values
+ * style({ width: 100, height: 0 })
+ * ```
+ *
+ * The following example uses auto-styling to allow an element to animate from
+ * a height of 0 up to its full height:
+ *
+ * ```ts
+ * style({ height: 0 }),
+ * animate("1s", style({ height: "*" }))
+ * ```
+ *
+ * @publicApi
+ **/
+declare function style(tokens: '*' | {
+    [key: string]: string | number;
+} | Array<'*' | {
+    [key: string]: string | number;
+}>): AnimationStyleMetadata;
+/**
+ * Declares an animation state within a trigger attached to an element.
+ *
+ * @param name One or more names for the defined state in a comma-separated string.
+ * The following reserved state names can be supplied to define a style for specific use
+ * cases:
+ *
+ * - `void` You can associate styles with this name to be used when
+ * the element is detached from the application. For example, when an `ngIf` evaluates
+ * to false, the state of the associated element is void.
+ *  - `*` (asterisk) Indicates the default state. You can associate styles with this name
+ * to be used as the fallback when the state that is being animated is not declared
+ * within the trigger.
+ *
+ * @param styles A set of CSS styles associated with this state, created using the
+ * `style()` function.
+ * This set of styles persists on the element once the state has been reached.
+ * @param options Parameters that can be passed to the state when it is invoked.
+ * 0 or more key-value pairs.
+ * @return An object that encapsulates the new state data.
+ *
+ * @usageNotes
+ * Use the `trigger()` function to register states to an animation trigger.
+ * Use the `transition()` function to animate between states.
+ * When a state is active within a component, its associated styles persist on the element,
+ * even when the animation ends.
+ *
+ * @publicApi
+ **/
+declare function state(name: string, styles: AnimationStyleMetadata, options?: {
+    params: {
+        [name: string]: any;
+    };
+}): AnimationStateMetadata;
+/**
+ * Defines a set of animation styles, associating each style with an optional `offset` value.
+ *
+ * @param steps A set of animation styles with optional offset data.
+ * The optional `offset` value for a style specifies a percentage of the total animation
+ * time at which that style is applied.
+ * @returns An object that encapsulates the keyframes data.
+ *
+ * @usageNotes
+ * Use with the `animate()` call. Instead of applying animations
+ * from the current state
+ * to the destination state, keyframes describe how each style entry is applied and at what point
+ * within the animation arc.
+ * Compare [CSS Keyframe Animations](https://www.w3schools.com/css/css3_animations.asp).
+ *
+ * ### Usage
+ *
+ * In the following example, the offset values describe
+ * when each `backgroundColor` value is applied. The color is red at the start, and changes to
+ * blue when 20% of the total time has elapsed.
+ *
+ * ```ts
+ * // the provided offset values
+ * animate("5s", keyframes([
+ *   style({ backgroundColor: "red", offset: 0 }),
+ *   style({ backgroundColor: "blue", offset: 0.2 }),
+ *   style({ backgroundColor: "orange", offset: 0.3 }),
+ *   style({ backgroundColor: "black", offset: 1 })
+ * ]))
+ * ```
+ *
+ * If there are no `offset` values specified in the style entries, the offsets
+ * are calculated automatically.
+ *
+ * ```ts
+ * animate("5s", keyframes([
+ *   style({ backgroundColor: "red" }) // offset = 0
+ *   style({ backgroundColor: "blue" }) // offset = 0.33
+ *   style({ backgroundColor: "orange" }) // offset = 0.66
+ *   style({ backgroundColor: "black" }) // offset = 1
+ * ]))
+ *```
+
+ * @publicApi
+ */
+declare function keyframes(steps: AnimationStyleMetadata[]): AnimationKeyframesSequenceMetadata;
+/**
+ * Declares an animation transition which is played when a certain specified condition is met.
+ *
+ * @param stateChangeExpr A string with a specific format or a function that specifies when the
+ * animation transition should occur (see [State Change Expression](#state-change-expression)).
+ *
+ * @param steps One or more animation objects that represent the animation's instructions.
+ *
+ * @param options An options object that can be used to specify a delay for the animation or provide
+ * custom parameters for it.
+ *
+ * @returns An object that encapsulates the transition data.
+ *
+ * @usageNotes
+ *
+ * ### State Change Expression
+ *
+ * The State Change Expression instructs Angular when to run the transition's animations, it can
+ *either be
+ *  - a string with a specific syntax
+ *  - or a function that compares the previous and current state (value of the expression bound to
+ *    the element's trigger) and returns `true` if the transition should occur or `false` otherwise
+ *
+ * The string format can be:
+ *  - `fromState => toState`, which indicates that the transition's animations should occur then the
+ *    expression bound to the trigger's element goes from `fromState` to `toState`
+ *
+ *    _Example:_
+ *      ```ts
+ *        transition('open => closed', animate('.5s ease-out', style({ height: 0 }) ))
+ *      ```
+ *
+ *  - `fromState <=> toState`, which indicates that the transition's animations should occur then
+ *    the expression bound to the trigger's element goes from `fromState` to `toState` or vice versa
+ *
+ *    _Example:_
+ *      ```ts
+ *        transition('enabled <=> disabled', animate('1s cubic-bezier(0.8,0.3,0,1)'))
+ *      ```
+ *
+ *  - `:enter`/`:leave`, which indicates that the transition's animations should occur when the
+ *    element enters or exists the DOM
+ *
+ *    _Example:_
+ *      ```ts
+ *        transition(':enter', [
+ *          style({ opacity: 0 }),
+ *          animate('500ms', style({ opacity: 1 }))
+ *        ])
+ *      ```
+ *
+ *  - `:increment`/`:decrement`, which indicates that the transition's animations should occur when
+ *    the numerical expression bound to the trigger's element has increased in value or decreased
+ *
+ *    _Example:_
+ *      ```ts
+ *        transition(':increment', query('@counter', animateChild()))
+ *      ```
+ *
+ *  - a sequence of any of the above divided by commas, which indicates that transition's animations
+ *    should occur whenever one of the state change expressions matches
+ *
+ *    _Example:_
+ *      ```ts
+ *        transition(':increment, * => enabled, :enter', animate('1s ease', keyframes([
+ *          style({ transform: 'scale(1)', offset: 0}),
+ *          style({ transform: 'scale(1.1)', offset: 0.7}),
+ *          style({ transform: 'scale(1)', offset: 1})
+ *        ]))),
+ *      ```
+ *
+ * Also note that in such context:
+ *  - `void` can be used to indicate the absence of the element
+ *  - asterisks can be used as wildcards that match any state
+ *  - (as a consequence of the above, `void => *` is equivalent to `:enter` and `* => void` is
+ *    equivalent to `:leave`)
+ *  - `true` and `false` also match expression values of `1` and `0` respectively (but do not match
+ *    _truthy_ and _falsy_ values)
+ *
+ * <div class="docs-alert docs-alert-helpful">
+ *
+ *  Be careful about entering end leaving elements as their transitions present a common
+ *  pitfall for developers.
+ *
+ *  Note that when an element with a trigger enters the DOM its `:enter` transition always
+ *  gets executed, but its `:leave` transition will not be executed if the element is removed
+ *  alongside its parent (as it will be removed "without warning" before its transition has
+ *  a chance to be executed, the only way that such transition can occur is if the element
+ *  is exiting the DOM on its own).
+ *
+ *
+ * </div>
+ *
+ * ### Animating to a Final State
+ *
+ * If the final step in a transition is a call to `animate()` that uses a timing value
+ * with no `style` data, that step is automatically considered the final animation arc,
+ * for the element to reach the final state, in such case Angular automatically adds or removes
+ * CSS styles to ensure that the element is in the correct final state.
+ *
+ *
+ * ### Usage Examples
+ *
+ *  - Transition animations applied based on
+ *    the trigger's expression value
+ *
+ *   ```html
+ *   <div [@myAnimationTrigger]="myStatusExp">
+ *    ...
+ *   </div>
+ *   ```
+ *
+ *   ```ts
+ *   trigger("myAnimationTrigger", [
+ *     ..., // states
+ *     transition("on => off, open => closed", animate(500)),
+ *     transition("* <=> error", query('.indicator', animateChild()))
+ *   ])
+ *   ```
+ *
+ *  - Transition animations applied based on custom logic dependent
+ *    on the trigger's expression value and provided parameters
+ *
+ *    ```html
+ *    <div [@myAnimationTrigger]="{
+ *     value: stepName,
+ *     params: { target: currentTarget }
+ *    }">
+ *     ...
+ *    </div>
+ *    ```
+ *
+ *    ```ts
+ *    trigger("myAnimationTrigger", [
+ *      ..., // states
+ *      transition(
+ *        (fromState, toState, _element, params) =>
+ *          ['firststep', 'laststep'].includes(fromState.toLowerCase())
+ *          && toState === params?.['target'],
+ *        animate('1s')
+ *      )
+ *    ])
+ *    ```
+ *
+ * @publicApi
+ **/
+declare function transition(stateChangeExpr: string | ((fromState: string, toState: string, element?: any, params?: {
+    [key: string]: any;
+}) => boolean), steps: AnimationMetadata | AnimationMetadata[], options?: AnimationOptions | null): AnimationTransitionMetadata;
+/**
+ * Produces a reusable animation that can be invoked in another animation or sequence,
+ * by calling the `useAnimation()` function.
+ *
+ * @param steps One or more animation objects, as returned by the `animate()`
+ * or `sequence()` function, that form a transformation from one state to another.
+ * A sequence is used by default when you pass an array.
+ * @param options An options object that can contain a delay value for the start of the
+ * animation, and additional developer-defined parameters.
+ * Provided values for additional parameters are used as defaults,
+ * and override values can be passed to the caller on invocation.
+ * @returns An object that encapsulates the animation data.
+ *
+ * @usageNotes
+ * The following example defines a reusable animation, providing some default parameter
+ * values.
+ *
+ * ```ts
+ * var fadeAnimation = animation([
+ *   style({ opacity: '{{ start }}' }),
+ *   animate('{{ time }}',
+ *   style({ opacity: '{{ end }}'}))
+ *   ],
+ *   { params: { time: '1000ms', start: 0, end: 1 }});
+ * ```
+ *
+ * The following invokes the defined animation with a call to `useAnimation()`,
+ * passing in override parameter values.
+ *
+ * ```js
+ * useAnimation(fadeAnimation, {
+ *   params: {
+ *     time: '2s',
+ *     start: 1,
+ *     end: 0
+ *   }
+ * })
+ * ```
+ *
+ * If any of the passed-in parameter values are missing from this call,
+ * the default values are used. If one or more parameter values are missing before a step is
+ * animated, `useAnimation()` throws an error.
+ *
+ * @publicApi
+ */
+declare function animation(steps: AnimationMetadata | AnimationMetadata[], options?: AnimationOptions | null): AnimationReferenceMetadata;
+/**
+ * Executes a queried inner animation element within an animation sequence.
+ *
+ * @param options An options object that can contain a delay value for the start of the
+ * animation, and additional override values for developer-defined parameters.
+ * @return An object that encapsulates the child animation data.
+ *
+ * @usageNotes
+ * Each time an animation is triggered in Angular, the parent animation
+ * has priority and any child animations are blocked. In order
+ * for a child animation to run, the parent animation must query each of the elements
+ * containing child animations, and run them using this function.
+ *
+ * Note that this feature is designed to be used with `query()` and it will only work
+ * with animations that are assigned using the Angular animation library. CSS keyframes
+ * and transitions are not handled by this API.
+ *
+ * @publicApi
+ */
+declare function animateChild(options?: AnimateChildOptions | null): AnimationAnimateChildMetadata;
+/**
+ * Starts a reusable animation that is created using the `animation()` function.
+ *
+ * @param animation The reusable animation to start.
+ * @param options An options object that can contain a delay value for the start of
+ * the animation, and additional override values for developer-defined parameters.
+ * @return An object that contains the animation parameters.
+ *
+ * @publicApi
+ */
+declare function useAnimation(animation: AnimationReferenceMetadata, options?: AnimationOptions | null): AnimationAnimateRefMetadata;
+/**
+ * Finds one or more inner elements within the current element that is
+ * being animated within a sequence. Use with `animate()`.
+ *
+ * @param selector The element to query, or a set of elements that contain Angular-specific
+ * characteristics, specified with one or more of the following tokens.
+ *  - `query(":enter")` or `query(":leave")` : Query for newly inserted/removed elements (not
+ *     all elements can be queried via these tokens, see
+ *     [Entering and Leaving Elements](#entering-and-leaving-elements))
+ *  - `query(":animating")` : Query all currently animating elements.
+ *  - `query("@triggerName")` : Query elements that contain an animation trigger.
+ *  - `query("@*")` : Query all elements that contain an animation triggers.
+ *  - `query(":self")` : Include the current element into the animation sequence.
+ *
+ * @param animation One or more animation steps to apply to the queried element or elements.
+ * An array is treated as an animation sequence.
+ * @param options An options object. Use the 'limit' field to limit the total number of
+ * items to collect.
+ * @return An object that encapsulates the query data.
+ *
+ * @usageNotes
+ *
+ * ### Multiple Tokens
+ *
+ * Tokens can be merged into a combined query selector string. For example:
+ *
+ * ```ts
+ *  query(':self, .record:enter, .record:leave, @subTrigger', [...])
+ * ```
+ *
+ * The `query()` function collects multiple elements and works internally by using
+ * `element.querySelectorAll`. Use the `limit` field of an options object to limit
+ * the total number of items to be collected. For example:
+ *
+ * ```js
+ * query('div', [
+ *   animate(...),
+ *   animate(...)
+ * ], { limit: 1 })
+ * ```
+ *
+ * By default, throws an error when zero items are found. Set the
+ * `optional` flag to ignore this error. For example:
+ *
+ * ```js
+ * query('.some-element-that-may-not-be-there', [
+ *   animate(...),
+ *   animate(...)
+ * ], { optional: true })
+ * ```
+ *
+ * ### Entering and Leaving Elements
+ *
+ * Not all elements can be queried via the `:enter` and `:leave` tokens, the only ones
+ * that can are those that Angular assumes can enter/leave based on their own logic
+ * (if their insertion/removal is simply a consequence of that of their parent they
+ * should be queried via a different token in their parent's `:enter`/`:leave` transitions).
+ *
+ * The only elements Angular assumes can enter/leave based on their own logic (thus the only
+ * ones that can be queried via the `:enter` and `:leave` tokens) are:
+ *  - Those inserted dynamically (via `ViewContainerRef`)
+ *  - Those that have a structural directive (which, under the hood, are a subset of the above ones)
+ *
+ * <div class="docs-alert docs-alert-helpful">
+ *
+ *  Note that elements will be successfully queried via `:enter`/`:leave` even if their
+ *  insertion/removal is not done manually via `ViewContainerRef`or caused by their structural
+ *  directive (e.g. they enter/exit alongside their parent).
+ *
+ * </div>
+ *
+ * <div class="docs-alert docs-alert-important">
+ *
+ *  There is an exception to what previously mentioned, besides elements entering/leaving based on
+ *  their own logic, elements with an animation trigger can always be queried via `:leave` when
+ * their parent is also leaving.
+ *
+ * </div>
+ *
+ * ### Usage Example
+ *
+ * The following example queries for inner elements and animates them
+ * individually using `animate()`.
+ *
+ * ```angular-ts
+ * @Component({
+ *   selector: 'inner',
+ *   template: `
+ *     <div [@queryAnimation]="exp">
+ *       <h1>Title</h1>
+ *       <div class="content">
+ *         Blah blah blah
+ *       </div>
+ *     </div>
+ *   `,
+ *   animations: [
+ *    trigger('queryAnimation', [
+ *      transition('* => goAnimate', [
+ *        // hide the inner elements
+ *        query('h1', style({ opacity: 0 })),
+ *        query('.content', style({ opacity: 0 })),
+ *
+ *        // animate the inner elements in, one by one
+ *        query('h1', animate(1000, style({ opacity: 1 }))),
+ *        query('.content', animate(1000, style({ opacity: 1 }))),
+ *      ])
+ *    ])
+ *  ]
+ * })
+ * class Cmp {
+ *   exp = '';
+ *
+ *   goAnimate() {
+ *     this.exp = 'goAnimate';
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+declare function query(selector: string, animation: AnimationMetadata | AnimationMetadata[], options?: AnimationQueryOptions | null): AnimationQueryMetadata;
+/**
+ * Use within an animation `query()` call to issue a timing gap after
+ * each queried item is animated.
+ *
+ * @param timings A delay value.
+ * @param animation One ore more animation steps.
+ * @returns An object that encapsulates the stagger data.
+ *
+ * @usageNotes
+ * In the following example, a container element wraps a list of items stamped out
+ * by an `ngFor`. The container element contains an animation trigger that will later be set
+ * to query for each of the inner items.
+ *
+ * Each time items are added, the opacity fade-in animation runs,
+ * and each removed item is faded out.
+ * When either of these animations occur, the stagger effect is
+ * applied after each item's animation is started.
+ *
+ * ```html
+ * <!-- list.component.html -->
+ * <button (click)="toggle()">Show / Hide Items</button>
+ * <hr />
+ * <div [@listAnimation]="items.length">
+ *   <div *ngFor="let item of items">
+ *     {{ item }}
+ *   </div>
+ * </div>
+ * ```
+ *
+ * Here is the component code:
+ *
+ * ```ts
+ * import {trigger, transition, style, animate, query, stagger} from '@angular/animations';
+ * @Component({
+ *   templateUrl: 'list.component.html',
+ *   animations: [
+ *     trigger('listAnimation', [
+ *     ...
+ *     ])
+ *   ]
+ * })
+ * class ListComponent {
+ *   items = [];
+ *
+ *   showItems() {
+ *     this.items = [0,1,2,3,4];
+ *   }
+ *
+ *   hideItems() {
+ *     this.items = [];
+ *   }
+ *
+ *   toggle() {
+ *     this.items.length ? this.hideItems() : this.showItems();
+ *    }
+ *  }
+ * ```
+ *
+ * Here is the animation trigger code:
+ *
+ * ```ts
+ * trigger('listAnimation', [
+ *   transition('* => *', [ // each time the binding value changes
+ *     query(':leave', [
+ *       stagger(100, [
+ *         animate('0.5s', style({ opacity: 0 }))
+ *       ])
+ *     ]),
+ *     query(':enter', [
+ *       style({ opacity: 0 }),
+ *       stagger(100, [
+ *         animate('0.5s', style({ opacity: 1 }))
+ *       ])
+ *     ])
+ *   ])
+ * ])
+ * ```
+ *
+ * @publicApi
+ */
+declare function stagger(timings: string | number, animation: AnimationMetadata | AnimationMetadata[]): AnimationStaggerMetadata;
+
+/**
+ * Provides programmatic control of a reusable animation sequence,
+ * built using the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>
+ * method which returns an `AnimationFactory`, whose
+ * <code>[create](api/animations/AnimationFactory#create)()</code> method instantiates and
+ * initializes this interface.
+ *
+ * @see {@link AnimationBuilder}
+ * @see {@link AnimationFactory}
+ * @see {@link animate}
+ *
+ * @publicApi
+ */
+interface AnimationPlayer {
+    /**
+     * Provides a callback to invoke when the animation finishes.
+     * @param fn The callback function.
+     * @see {@link #finish}
+     */
+    onDone(fn: () => void): void;
+    /**
+     * Provides a callback to invoke when the animation starts.
+     * @param fn The callback function.
+     * @see {@link #play}
+     */
+    onStart(fn: () => void): void;
+    /**
+     * Provides a callback to invoke after the animation is destroyed.
+     * @param fn The callback function.
+     * @see {@link #destroy}
+     * @see {@link #beforeDestroy}
+     */
+    onDestroy(fn: () => void): void;
+    /**
+     * Initializes the animation.
+     */
+    init(): void;
+    /**
+     * Reports whether the animation has started.
+     * @returns True if the animation has started, false otherwise.
+     */
+    hasStarted(): boolean;
+    /**
+     * Runs the animation, invoking the `onStart()` callback.
+     */
+    play(): void;
+    /**
+     * Pauses the animation.
+     */
+    pause(): void;
+    /**
+     * Restarts the paused animation.
+     */
+    restart(): void;
+    /**
+     * Ends the animation, invoking the `onDone()` callback.
+     */
+    finish(): void;
+    /**
+     * Destroys the animation, after invoking the `beforeDestroy()` callback.
+     * Calls the `onDestroy()` callback when destruction is completed.
+     */
+    destroy(): void;
+    /**
+     * Resets the animation to its initial state.
+     */
+    reset(): void;
+    /**
+     * Sets the position of the animation.
+     * @param position A fractional value, representing the progress through the animation.
+     */
+    setPosition(position: number): void;
+    /**
+     * Reports the current position of the animation.
+     * @returns A fractional value, representing the progress through the animation.
+     */
+    getPosition(): number;
+    /**
+     * The parent of this player, if any.
+     */
+    parentPlayer: AnimationPlayer | null;
+    /**
+     * The total run time of the animation, in milliseconds.
+     */
+    readonly totalTime: number;
+    /**
+     * Provides a callback to invoke before the animation is destroyed.
+     */
+    beforeDestroy?: () => any;
+}
+/**
+ * An empty programmatic controller for reusable animations.
+ * Used internally when animations are disabled, to avoid
+ * checking for the null case when an animation player is expected.
+ *
+ * @see {@link animate}
+ * @see {@link AnimationPlayer}
+ *
+ * @publicApi
+ */
+declare class NoopAnimationPlayer implements AnimationPlayer {
+    private _onDoneFns;
+    private _onStartFns;
+    private _onDestroyFns;
+    private _originalOnDoneFns;
+    private _originalOnStartFns;
+    private _started;
+    private _destroyed;
+    private _finished;
+    private _position;
+    parentPlayer: AnimationPlayer | null;
+    readonly totalTime: number;
+    constructor(duration?: number, delay?: number);
+    private _onFinish;
+    onStart(fn: () => void): void;
+    onDone(fn: () => void): void;
+    onDestroy(fn: () => void): void;
+    hasStarted(): boolean;
+    init(): void;
+    play(): void;
+    private _onStart;
+    pause(): void;
+    restart(): void;
+    finish(): void;
+    destroy(): void;
+    reset(): void;
+    setPosition(position: number): void;
+    getPosition(): number;
+}
+
+export { AUTO_STYLE, AnimationMetadataType, NoopAnimationPlayer, animate, animateChild, animation, group, keyframes, query, sequence, stagger, state, style, transition, trigger, useAnimation };
+export type { AnimateChildOptions, AnimateTimings, AnimationAnimateChildMetadata, AnimationAnimateMetadata, AnimationAnimateRefMetadata, AnimationGroupMetadata, AnimationKeyframesSequenceMetadata, AnimationMetadata, AnimationOptions, AnimationPlayer, AnimationQueryMetadata, AnimationQueryOptions, AnimationReferenceMetadata, AnimationSequenceMetadata, AnimationStaggerMetadata, AnimationStateMetadata, AnimationStyleMetadata, AnimationTransitionMetadata, AnimationTriggerMetadata, ɵStyleData, ɵStyleDataMap };

node_modules/@angular/animations/browser/index.d.ts

@@ -0,0 +1,275 @@
+/**
+ * @license Angular v19.2.13
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import { AnimationDriver } from '../animation_driver.d-DAiEDqQt.js';
+export { NoopAnimationDriver } from '../animation_driver.d-DAiEDqQt.js';
+import { AnimationTriggerMetadata, AnimationPlayer, ɵStyleDataMap as _StyleDataMap, AnimationMetadata, AnimationOptions, ɵStyleData as _StyleData } from '../animation_player.d-Dv9iW4uh.js';
+import { Renderer2, ɵAnimationRendererType as _AnimationRendererType, RendererStyleFlags2, ListenerOptions, RendererFactory2, NgZone, RendererType2 } from '@angular/core';
+
+declare abstract class AnimationStyleNormalizer {
+    abstract normalizePropertyName(propertyName: string, errors: Error[]): string;
+    abstract normalizeStyleValue(userProvidedProperty: string, normalizedProperty: string, value: string | number, errors: Error[]): string;
+}
+declare class NoopAnimationStyleNormalizer {
+    normalizePropertyName(propertyName: string, errors: Error[]): string;
+    normalizeStyleValue(userProvidedProperty: string, normalizedProperty: string, value: string | number, errors: Error[]): string;
+}
+
+declare class AnimationEngine {
+    private _driver;
+    private _normalizer;
+    private _transitionEngine;
+    private _timelineEngine;
+    private _triggerCache;
+    onRemovalComplete: (element: any, context: any) => void;
+    constructor(doc: Document, _driver: AnimationDriver, _normalizer: AnimationStyleNormalizer);
+    registerTrigger(componentId: string, namespaceId: string, hostElement: any, name: string, metadata: AnimationTriggerMetadata): void;
+    register(namespaceId: string, hostElement: any): void;
+    destroy(namespaceId: string, context: any): void;
+    onInsert(namespaceId: string, element: any, parent: any, insertBefore: boolean): void;
+    onRemove(namespaceId: string, element: any, context: any): void;
+    disableAnimations(element: any, disable: boolean): void;
+    process(namespaceId: string, element: any, property: string, value: any): void;
+    listen(namespaceId: string, element: any, eventName: string, eventPhase: string, callback: (event: any) => any): () => any;
+    flush(microtaskId?: number): void;
+    get players(): AnimationPlayer[];
+    whenRenderingDone(): Promise<any>;
+    afterFlushAnimationsDone(cb: VoidFunction): void;
+}
+
+declare function createEngine(type: 'animations' | 'noop', doc: Document): AnimationEngine;
+
+declare const enum AnimationTransitionInstructionType {
+    TransitionAnimation = 0,
+    TimelineAnimation = 1
+}
+interface AnimationEngineInstruction {
+    type: AnimationTransitionInstructionType;
+}
+
+interface AnimationTimelineInstruction extends AnimationEngineInstruction {
+    element: any;
+    keyframes: Array<_StyleDataMap>;
+    preStyleProps: string[];
+    postStyleProps: string[];
+    duration: number;
+    delay: number;
+    totalTime: number;
+    easing: string | null;
+    stretchStartingKeyframe?: boolean;
+    subTimeline: boolean;
+}
+
+declare class ElementInstructionMap {
+    private _map;
+    get(element: any): AnimationTimelineInstruction[];
+    append(element: any, instructions: AnimationTimelineInstruction[]): void;
+    has(element: any): boolean;
+    clear(): void;
+}
+
+declare class Animation$1 {
+    private _driver;
+    private _animationAst;
+    constructor(_driver: AnimationDriver, input: AnimationMetadata | AnimationMetadata[]);
+    buildTimelines(element: any, startingStyles: _StyleDataMap | Array<_StyleDataMap>, destinationStyles: _StyleDataMap | Array<_StyleDataMap>, options: AnimationOptions, subInstructions?: ElementInstructionMap): AnimationTimelineInstruction[];
+}
+
+declare class WebAnimationsStyleNormalizer extends AnimationStyleNormalizer {
+    normalizePropertyName(propertyName: string, errors: Error[]): string;
+    normalizeStyleValue(userProvidedProperty: string, normalizedProperty: string, value: string | number, errors: Error[]): string;
+}
+
+type AnimationFactoryWithListenerCallback = RendererFactory2 & {
+    scheduleListenerCallback: (count: number, fn: (e: any) => any, data: any) => void;
+};
+declare class BaseAnimationRenderer implements Renderer2 {
+    protected namespaceId: string;
+    delegate: Renderer2;
+    engine: AnimationEngine;
+    private _onDestroy?;
+    readonly ɵtype: _AnimationRendererType.Regular;
+    constructor(namespaceId: string, delegate: Renderer2, engine: AnimationEngine, _onDestroy?: (() => void) | undefined);
+    get data(): {
+        [key: string]: any;
+    };
+    destroyNode(node: any): void;
+    destroy(): void;
+    createElement(name: string, namespace?: string | null | undefined): any;
+    createComment(value: string): any;
+    createText(value: string): any;
+    appendChild(parent: any, newChild: any): void;
+    insertBefore(parent: any, newChild: any, refChild: any, isMove?: boolean): void;
+    removeChild(parent: any, oldChild: any, isHostElement?: boolean): void;
+    selectRootElement(selectorOrNode: any, preserveContent?: boolean): any;
+    parentNode(node: any): any;
+    nextSibling(node: any): any;
+    setAttribute(el: any, name: string, value: string, namespace?: string | null | undefined): void;
+    removeAttribute(el: any, name: string, namespace?: string | null | undefined): void;
+    addClass(el: any, name: string): void;
+    removeClass(el: any, name: string): void;
+    setStyle(el: any, style: string, value: any, flags?: RendererStyleFlags2 | undefined): void;
+    removeStyle(el: any, style: string, flags?: RendererStyleFlags2 | undefined): void;
+    setProperty(el: any, name: string, value: any): void;
+    setValue(node: any, value: string): void;
+    listen(target: any, eventName: string, callback: (event: any) => boolean | void, options?: ListenerOptions): () => void;
+    protected disableAnimations(element: any, value: boolean): void;
+}
+declare class AnimationRenderer extends BaseAnimationRenderer implements Renderer2 {
+    factory: AnimationFactoryWithListenerCallback;
+    constructor(factory: AnimationFactoryWithListenerCallback, namespaceId: string, delegate: Renderer2, engine: AnimationEngine, onDestroy?: () => void);
+    setProperty(el: any, name: string, value: any): void;
+    listen(target: 'window' | 'document' | 'body' | any, eventName: string, callback: (event: any) => any, options?: ListenerOptions): () => void;
+}
+
+declare class AnimationRendererFactory implements RendererFactory2 {
+    private delegate;
+    private engine;
+    private _zone;
+    private _currentId;
+    private _microtaskId;
+    private _animationCallbacksBuffer;
+    private _rendererCache;
+    private _cdRecurDepth;
+    constructor(delegate: RendererFactory2, engine: AnimationEngine, _zone: NgZone);
+    createRenderer(hostElement: any, type: RendererType2): BaseAnimationRenderer;
+    begin(): void;
+    private _scheduleCountTask;
+    end(): void;
+    whenRenderingDone(): Promise<any>;
+    /**
+     * Used during HMR to clear any cached data about a component.
+     * @param componentId ID of the component that is being replaced.
+     */
+    protected componentReplaced(componentId: string): void;
+}
+
+declare function getParentElement(element: any): unknown | null;
+declare function validateStyleProperty(prop: string): boolean;
+declare function validateWebAnimatableStyleProperty(prop: string): boolean;
+declare function containsElement(elm1: any, elm2: any): boolean;
+declare function invokeQuery(element: any, selector: string, multi: boolean): any[];
+
+declare class WebAnimationsDriver implements AnimationDriver {
+    validateStyleProperty(prop: string): boolean;
+    validateAnimatableStyleProperty(prop: string): boolean;
+    containsElement(elm1: any, elm2: any): boolean;
+    getParentElement(element: unknown): unknown;
+    query(element: any, selector: string, multi: boolean): any[];
+    computeStyle(element: any, prop: string, defaultValue?: string): string;
+    animate(element: any, keyframes: Array<Map<string, string | number>>, duration: number, delay: number, easing: string, previousPlayers?: AnimationPlayer[]): AnimationPlayer;
+}
+
+/**
+ * Designed to be executed during a keyframe-based animation to apply any special-cased styles.
+ *
+ * When started (when the `start()` method is run) then the provided `startStyles`
+ * will be applied. When finished (when the `finish()` method is called) the
+ * `endStyles` will be applied as well any any starting styles. Finally when
+ * `destroy()` is called then all styles will be removed.
+ */
+declare class SpecialCasedStyles {
+    private _element;
+    private _startStyles;
+    private _endStyles;
+    static initialStylesByElement: WeakMap<any, _StyleDataMap>;
+    private _state;
+    private _initialStyles;
+    constructor(_element: any, _startStyles: _StyleDataMap | null, _endStyles: _StyleDataMap | null);
+    start(): void;
+    finish(): void;
+    destroy(): void;
+}
+
+declare class WebAnimationsPlayer implements AnimationPlayer {
+    element: any;
+    keyframes: Array<_StyleDataMap>;
+    options: {
+        [key: string]: string | number;
+    };
+    private _specialStyles?;
+    private _onDoneFns;
+    private _onStartFns;
+    private _onDestroyFns;
+    private _duration;
+    private _delay;
+    private _initialized;
+    private _finished;
+    private _started;
+    private _destroyed;
+    private _finalKeyframe?;
+    private _originalOnDoneFns;
+    private _originalOnStartFns;
+    readonly domPlayer: Animation;
+    time: number;
+    parentPlayer: AnimationPlayer | null;
+    currentSnapshot: _StyleDataMap;
+    constructor(element: any, keyframes: Array<_StyleDataMap>, options: {
+        [key: string]: string | number;
+    }, _specialStyles?: (SpecialCasedStyles | null) | undefined);
+    private _onFinish;
+    init(): void;
+    private _buildPlayer;
+    private _preparePlayerBeforeStart;
+    private _convertKeyframesToObject;
+    onStart(fn: () => void): void;
+    onDone(fn: () => void): void;
+    onDestroy(fn: () => void): void;
+    play(): void;
+    pause(): void;
+    finish(): void;
+    reset(): void;
+    private _resetDomPlayerState;
+    restart(): void;
+    hasStarted(): boolean;
+    destroy(): void;
+    setPosition(p: number): void;
+    getPosition(): number;
+    get totalTime(): number;
+    beforeDestroy(): void;
+}
+
+declare const ENTER_CLASSNAME = "ng-enter";
+declare const LEAVE_CLASSNAME = "ng-leave";
+declare function normalizeKeyframes(keyframes: Array<_StyleData> | Array<_StyleDataMap>): Array<_StyleDataMap>;
+declare function camelCaseToDashCase(input: string): string;
+declare function allowPreviousPlayerStylesMerge(duration: number, delay: number): boolean;
+
+declare class TransitionAnimationPlayer implements AnimationPlayer {
+    namespaceId: string;
+    triggerName: string;
+    element: any;
+    private _player;
+    private _containsRealPlayer;
+    private _queuedCallbacks;
+    readonly destroyed = false;
+    parentPlayer: AnimationPlayer | null;
+    markedForDestroy: boolean;
+    disabled: boolean;
+    readonly queued: boolean;
+    readonly totalTime: number;
+    constructor(namespaceId: string, triggerName: string, element: any);
+    setRealPlayer(player: AnimationPlayer): void;
+    getRealPlayer(): AnimationPlayer;
+    overrideTotalTime(totalTime: number): void;
+    syncPlayerEvents(player: AnimationPlayer): void;
+    private _queueEvent;
+    onDone(fn: () => void): void;
+    onStart(fn: () => void): void;
+    onDestroy(fn: () => void): void;
+    init(): void;
+    hasStarted(): boolean;
+    play(): void;
+    pause(): void;
+    restart(): void;
+    finish(): void;
+    destroy(): void;
+    reset(): void;
+    setPosition(p: number): void;
+    getPosition(): number;
+}
+
+export { AnimationDriver, Animation$1 as ɵAnimation, AnimationEngine as ɵAnimationEngine, AnimationRenderer as ɵAnimationRenderer, AnimationRendererFactory as ɵAnimationRendererFactory, AnimationStyleNormalizer as ɵAnimationStyleNormalizer, BaseAnimationRenderer as ɵBaseAnimationRenderer, ENTER_CLASSNAME as ɵENTER_CLASSNAME, LEAVE_CLASSNAME as ɵLEAVE_CLASSNAME, NoopAnimationStyleNormalizer as ɵNoopAnimationStyleNormalizer, TransitionAnimationPlayer as ɵTransitionAnimationPlayer, WebAnimationsDriver as ɵWebAnimationsDriver, WebAnimationsPlayer as ɵWebAnimationsPlayer, WebAnimationsStyleNormalizer as ɵWebAnimationsStyleNormalizer, allowPreviousPlayerStylesMerge as ɵallowPreviousPlayerStylesMerge, camelCaseToDashCase as ɵcamelCaseToDashCase, containsElement as ɵcontainsElement, createEngine as ɵcreateEngine, getParentElement as ɵgetParentElement, invokeQuery as ɵinvokeQuery, normalizeKeyframes as ɵnormalizeKeyframes, validateStyleProperty as ɵvalidateStyleProperty, validateWebAnimatableStyleProperty as ɵvalidateWebAnimatableStyleProperty };

node_modules/@angular/animations/browser/testing/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @license Angular v19.2.13
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import { AnimationPlayer, ɵStyleDataMap as _StyleDataMap, NoopAnimationPlayer } from '../../animation_player.d-Dv9iW4uh.js';
+import { AnimationDriver } from '../../animation_driver.d-DAiEDqQt.js';
+import '@angular/core';
+
+/**
+ * @publicApi
+ */
+declare class MockAnimationDriver implements AnimationDriver {
+    static log: AnimationPlayer[];
+    validateStyleProperty(prop: string): boolean;
+    validateAnimatableStyleProperty(prop: string): boolean;
+    containsElement(elm1: any, elm2: any): boolean;
+    getParentElement(element: unknown): unknown;
+    query(element: any, selector: string, multi: boolean): any[];
+    computeStyle(element: any, prop: string, defaultValue?: string): string;
+    animate(element: any, keyframes: Array<_StyleDataMap>, duration: number, delay: number, easing: string, previousPlayers?: any[]): MockAnimationPlayer;
+}
+/**
+ * @publicApi
+ */
+declare class MockAnimationPlayer extends NoopAnimationPlayer {
+    element: any;
+    keyframes: Array<_StyleDataMap>;
+    duration: number;
+    delay: number;
+    easing: string;
+    previousPlayers: any[];
+    private __finished;
+    private __started;
+    previousStyles: _StyleDataMap;
+    private _onInitFns;
+    currentSnapshot: _StyleDataMap;
+    private _keyframes;
+    constructor(element: any, keyframes: Array<_StyleDataMap>, duration: number, delay: number, easing: string, previousPlayers: any[]);
+    reset(): void;
+    finish(): void;
+    destroy(): void;
+    play(): void;
+    hasStarted(): boolean;
+    beforeDestroy(): void;
+}
+
+export { MockAnimationDriver, MockAnimationPlayer };

node_modules/@angular/animations/fesm2022/animations.mjs

@@ -0,0 +1,209 @@
+/**
+ * @license Angular v19.2.13
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import { DOCUMENT } from '@angular/common';
+import * as i0 from '@angular/core';
+import { inject, ANIMATION_MODULE_TYPE, ViewEncapsulation, ɵRuntimeError as _RuntimeError, Injectable, Inject } from '@angular/core';
+import { sequence } from './private_export-faY_wCkZ.mjs';
+export { AUTO_STYLE, AnimationMetadataType, NoopAnimationPlayer, animate, animateChild, animation, group, keyframes, query, stagger, state, style, transition, trigger, useAnimation, AnimationGroupPlayer as ɵAnimationGroupPlayer, ɵPRE_STYLE } from './private_export-faY_wCkZ.mjs';
+
+/**
+ * An injectable service that produces an animation sequence programmatically within an
+ * Angular component or directive.
+ * Provided by the `BrowserAnimationsModule` or `NoopAnimationsModule`.
+ *
+ * @usageNotes
+ *
+ * To use this service, add it to your component or directive as a dependency.
+ * The service is instantiated along with your component.
+ *
+ * Apps do not typically need to create their own animation players, but if you
+ * do need to, follow these steps:
+ *
+ * 1. Use the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code> method
+ * to create a programmatic animation. The method returns an `AnimationFactory` instance.
+ *
+ * 2. Use the factory object to create an `AnimationPlayer` and attach it to a DOM element.
+ *
+ * 3. Use the player object to control the animation programmatically.
+ *
+ * For example:
+ *
+ * ```ts
+ * // import the service from BrowserAnimationsModule
+ * import {AnimationBuilder} from '@angular/animations';
+ * // require the service as a dependency
+ * class MyCmp {
+ *   constructor(private _builder: AnimationBuilder) {}
+ *
+ *   makeAnimation(element: any) {
+ *     // first define a reusable animation
+ *     const myAnimation = this._builder.build([
+ *       style({ width: 0 }),
+ *       animate(1000, style({ width: '100px' }))
+ *     ]);
+ *
+ *     // use the returned factory object to create a player
+ *     const player = myAnimation.create(element);
+ *
+ *     player.play();
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+class AnimationBuilder {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: AnimationBuilder, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: AnimationBuilder, providedIn: 'root', useFactory: () => inject(BrowserAnimationBuilder) });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: AnimationBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root', useFactory: () => inject(BrowserAnimationBuilder) }]
+        }] });
+/**
+ * A factory object returned from the
+ * <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>
+ * method.
+ *
+ * @publicApi
+ */
+class AnimationFactory {
+}
+class BrowserAnimationBuilder extends AnimationBuilder {
+    animationModuleType = inject(ANIMATION_MODULE_TYPE, { optional: true });
+    _nextAnimationId = 0;
+    _renderer;
+    constructor(rootRenderer, doc) {
+        super();
+        const typeData = {
+            id: '0',
+            encapsulation: ViewEncapsulation.None,
+            styles: [],
+            data: { animation: [] },
+        };
+        this._renderer = rootRenderer.createRenderer(doc.body, typeData);
+        if (this.animationModuleType === null && !isAnimationRenderer(this._renderer)) {
+            // We only support AnimationRenderer & DynamicDelegationRenderer for this AnimationBuilder
+            throw new _RuntimeError(3600 /* RuntimeErrorCode.BROWSER_ANIMATION_BUILDER_INJECTED_WITHOUT_ANIMATIONS */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
+                'Angular detected that the `AnimationBuilder` was injected, but animation support was not enabled. ' +
+                    'Please make sure that you enable animations in your application by calling `provideAnimations()` or `provideAnimationsAsync()` function.');
+        }
+    }
+    build(animation) {
+        const id = this._nextAnimationId;
+        this._nextAnimationId++;
+        const entry = Array.isArray(animation) ? sequence(animation) : animation;
+        issueAnimationCommand(this._renderer, null, id, 'register', [entry]);
+        return new BrowserAnimationFactory(id, this._renderer);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: BrowserAnimationBuilder, deps: [{ token: i0.RendererFactory2 }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: BrowserAnimationBuilder, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: BrowserAnimationBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.RendererFactory2 }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+class BrowserAnimationFactory extends AnimationFactory {
+    _id;
+    _renderer;
+    constructor(_id, _renderer) {
+        super();
+        this._id = _id;
+        this._renderer = _renderer;
+    }
+    create(element, options) {
+        return new RendererAnimationPlayer(this._id, element, options || {}, this._renderer);
+    }
+}
+class RendererAnimationPlayer {
+    id;
+    element;
+    _renderer;
+    parentPlayer = null;
+    _started = false;
+    constructor(id, element, options, _renderer) {
+        this.id = id;
+        this.element = element;
+        this._renderer = _renderer;
+        this._command('create', options);
+    }
+    _listen(eventName, callback) {
+        return this._renderer.listen(this.element, `@@${this.id}:${eventName}`, callback);
+    }
+    _command(command, ...args) {
+        issueAnimationCommand(this._renderer, this.element, this.id, command, args);
+    }
+    onDone(fn) {
+        this._listen('done', fn);
+    }
+    onStart(fn) {
+        this._listen('start', fn);
+    }
+    onDestroy(fn) {
+        this._listen('destroy', fn);
+    }
+    init() {
+        this._command('init');
+    }
+    hasStarted() {
+        return this._started;
+    }
+    play() {
+        this._command('play');
+        this._started = true;
+    }
+    pause() {
+        this._command('pause');
+    }
+    restart() {
+        this._command('restart');
+    }
+    finish() {
+        this._command('finish');
+    }
+    destroy() {
+        this._command('destroy');
+    }
+    reset() {
+        this._command('reset');
+        this._started = false;
+    }
+    setPosition(p) {
+        this._command('setPosition', p);
+    }
+    getPosition() {
+        return unwrapAnimationRenderer(this._renderer)?.engine?.players[this.id]?.getPosition() ?? 0;
+    }
+    totalTime = 0;
+}
+function issueAnimationCommand(renderer, element, id, command, args) {
+    renderer.setProperty(element, `@@${id}:${command}`, args);
+}
+/**
+ * The following 2 methods cannot reference their correct types (AnimationRenderer &
+ * DynamicDelegationRenderer) since this would introduce a import cycle.
+ */
+function unwrapAnimationRenderer(renderer) {
+    const type = renderer.ɵtype;
+    if (type === 0 /* AnimationRendererType.Regular */) {
+        return renderer;
+    }
+    else if (type === 1 /* AnimationRendererType.Delegated */) {
+        return renderer.animationRenderer;
+    }
+    return null;
+}
+function isAnimationRenderer(renderer) {
+    const type = renderer.ɵtype;
+    return type === 0 /* AnimationRendererType.Regular */ || type === 1 /* AnimationRendererType.Delegated */;
+}
+
+export { AnimationBuilder, AnimationFactory, sequence, BrowserAnimationBuilder as ɵBrowserAnimationBuilder };
+//# sourceMappingURL=animations.mjs.map

node_modules/@angular/animations/fesm2022/browser.mjs

@@ -0,0 +1,4170 @@
+/**
+ * @license Angular v19.2.13
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import * as i0 from '@angular/core';
+import { Injectable } from '@angular/core';
+import { validateStyleProperty, containsElement, getParentElement, invokeQuery, dashCaseToCamelCase, invalidCssUnitValue, invalidExpression, invalidTransitionAlias, visitDslNode, invalidTrigger, invalidDefinition, extractStyleParams, invalidState, invalidStyleValue, SUBSTITUTION_EXPR_START, invalidParallelAnimation, validateStyleParams, invalidKeyframes, invalidOffset, keyframeOffsetsOutOfOrder, keyframesMissingOffsets, getOrSetDefaultValue, invalidStagger, resolveTiming, normalizeAnimationEntry, NG_TRIGGER_SELECTOR, NG_ANIMATING_SELECTOR, resolveTimingValue, interpolateParams, invalidQuery, registerFailed, normalizeKeyframes, LEAVE_CLASSNAME, ENTER_CLASSNAME, missingOrDestroyedAnimation, createAnimationFailed, optimizeGroupPlayer, missingPlayer, listenOnPlayer, makeAnimationEvent, triggerTransitionsFailed, eraseStyles, setStyles, transitionFailed, missingTrigger, missingEvent, unsupportedTriggerEvent, unregisteredTrigger, NG_TRIGGER_CLASSNAME, NG_ANIMATING_CLASSNAME, triggerBuildFailed, parseTimelineCommand, computeStyle, camelCaseToDashCase, validateWebAnimatableStyleProperty, allowPreviousPlayerStylesMerge, normalizeKeyframes$1, balancePreviousStylesIntoKeyframes, validationFailed, normalizeStyles, buildingFailed } from './util-D9FfmVnv.mjs';
+import { NoopAnimationPlayer, AnimationMetadataType, style, AUTO_STYLE, ɵPRE_STYLE as _PRE_STYLE, AnimationGroupPlayer } from './private_export-faY_wCkZ.mjs';
+
+/**
+ * @publicApi
+ *
+ * `AnimationDriver` implentation for Noop animations
+ */
+class NoopAnimationDriver {
+    /**
+     * @returns Whether `prop` is a valid CSS property
+     */
+    validateStyleProperty(prop) {
+        return validateStyleProperty(prop);
+    }
+    /**
+     *
+     * @returns Whether elm1 contains elm2.
+     */
+    containsElement(elm1, elm2) {
+        return containsElement(elm1, elm2);
+    }
+    /**
+     * @returns Rhe parent of the given element or `null` if the element is the `document`
+     */
+    getParentElement(element) {
+        return getParentElement(element);
+    }
+    /**
+     * @returns The result of the query selector on the element. The array will contain up to 1 item
+     *     if `multi` is  `false`.
+     */
+    query(element, selector, multi) {
+        return invokeQuery(element, selector, multi);
+    }
+    /**
+     * @returns The `defaultValue` or empty string
+     */
+    computeStyle(element, prop, defaultValue) {
+        return defaultValue || '';
+    }
+    /**
+     * @returns An `NoopAnimationPlayer`
+     */
+    animate(element, keyframes, duration, delay, easing, previousPlayers = [], scrubberAccessRequested) {
+        return new NoopAnimationPlayer(duration, delay);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: NoopAnimationDriver, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: NoopAnimationDriver });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.13", ngImport: i0, type: NoopAnimationDriver, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * @publicApi
+ */
+class AnimationDriver {
+    /**
+     * @deprecated Use the NoopAnimationDriver class.
+     */
+    static NOOP = new NoopAnimationDriver();
+}
+
+class AnimationStyleNormalizer {
+}
+class NoopAnimationStyleNormalizer {
+    normalizePropertyName(propertyName, errors) {
+        return propertyName;
+    }
+    normalizeStyleValue(userProvidedProperty, normalizedProperty, value, errors) {
+        return value;
+    }
+}
+
+const DIMENSIONAL_PROP_SET = new Set([
+    'width',
+    'height',
+    'minWidth',
+    'minHeight',
+    'maxWidth',
+    'maxHeight',
+    'left',
+    'top',
+    'bottom',
+    'right',
+    'fontSize',
+    'outlineWidth',
+    'outlineOffset',
+    'paddingTop',
+    'paddingLeft',
+    'paddingBottom',
+    'paddingRight',
+    'marginTop',
+    'marginLeft',
+    'marginBottom',
+    'marginRight',
+    'borderRadius',
+    'borderWidth',
+    'borderTopWidth',
+    'borderLeftWidth',
+    'borderRightWidth',
+    'borderBottomWidth',
+    'textIndent',
+    'perspective',
+]);
+class WebAnimationsStyleNormalizer extends AnimationStyleNormalizer {
+    normalizePropertyName(propertyName, errors) {
+        return dashCaseToCamelCase(propertyName);
+    }
+    normalizeStyleValue(userProvidedProperty, normalizedProperty, value, errors) {
+        let unit = '';
+        const strVal = value.toString().trim();
+        if (DIMENSIONAL_PROP_SET.has(normalizedProperty) && value !== 0 && value !== '0') {
+            if (typeof value === 'number') {
+                unit = 'px';
+            }
+            else {
+                const valAndSuffixMatch = value.match(/^[+-]?[\d\.]+([a-z]*)$/);
+                if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) {
+                    errors.push(invalidCssUnitValue(userProvidedProperty, value));
+                }
+            }
+        }
+        return strVal + unit;
+    }
+}
+
+function createListOfWarnings(warnings) {
+    const LINE_START = '\n - ';
+    return `${LINE_START}${warnings
+        .filter(Boolean)
+        .map((warning) => warning)
+        .join(LINE_START)}`;
+}
+function warnValidation(warnings) {
+    console.warn(`animation validation warnings:${createListOfWarnings(warnings)}`);
+}
+function warnTriggerBuild(name, warnings) {
+    console.warn(`The animation trigger "${name}" has built with the following warnings:${createListOfWarnings(warnings)}`);
+}
+function warnRegister(warnings) {
+    console.warn(`Animation built with the following warnings:${createListOfWarnings(warnings)}`);
+}
+function pushUnrecognizedPropertiesWarning(warnings, props) {
+    if (props.length) {
+        warnings.push(`The following provided properties are not recognized: ${props.join(', ')}`);
+    }
+}
+
+const ANY_STATE = '*';
+function parseTransitionExpr(transitionValue, errors) {
+    const expressions = [];
+    if (typeof transitionValue == 'string') {
+        transitionValue
+            .split(/\s*,\s*/)
+            .forEach((str) => parseInnerTransitionStr(str, expressions, errors));
+    }
+    else {
+        expressions.push(transitionValue);
+    }
+    return expressions;
+}
+function parseInnerTransitionStr(eventStr, expressions, errors) {
+    if (eventStr[0] == ':') {
+        const result = parseAnimationAlias(eventStr, errors);
+        if (typeof result == 'function') {
+            expressions.push(result);
+            return;
+        }
+        eventStr = result;
+    }
+    const match = eventStr.match(/^(\*|[-\w]+)\s*(<?[=-]>)\s*(\*|[-\w]+)$/);
+    if (match == null || match.length < 4) {
+        errors.push(invalidExpression(eventStr));
+        return expressions;
+    }
+    const fromState = match[1];
+    const separator = match[2];
+    const toState = match[3];
+    expressions.push(makeLambdaFromStates(fromState, toState));
+    const isFullAnyStateExpr = fromState == ANY_STATE && toState == ANY_STATE;
+    if (separator[0] == '<' && !isFullAnyStateExpr) {
+        expressions.push(makeLambdaFromStates(toState, fromState));
+    }
+    return;
+}
+function parseAnimationAlias(alias, errors) {
+    switch (alias) {
+        case ':enter':
+            return 'void => *';
+        case ':leave':
+            return '* => void';
+        case ':increment':
+            return (fromState, toState) => parseFloat(toState) > parseFloat(fromState);
+        case ':decrement':
+            return (fromState, toState) => parseFloat(toState) < parseFloat(fromState);
+        default:
+            errors.push(invalidTransitionAlias(alias));
+            return '* => *';
+    }
+}
+// DO NOT REFACTOR ... keep the follow set instantiations
+// with the values intact (closure compiler for some reason
+// removes follow-up lines that add the values outside of
+// the constructor...
+const TRUE_BOOLEAN_VALUES = new Set(['true', '1']);
+const FALSE_BOOLEAN_VALUES = new Set(['false', '0']);
+function makeLambdaFromStates(lhs, rhs) {
+    const LHS_MATCH_BOOLEAN = TRUE_BOOLEAN_VALUES.has(lhs) || FALSE_BOOLEAN_VALUES.has(lhs);
+    const RHS_MATCH_BOOLEAN = TRUE_BOOLEAN_VALUES.has(rhs) || FALSE_BOOLEAN_VALUES.has(rhs);
+    return (fromState, toState) => {
+        let lhsMatch = lhs == ANY_STATE || lhs == fromState;
+        let rhsMatch = rhs == ANY_STATE || rhs == toState;
+        if (!lhsMatch && LHS_MATCH_BOOLEAN && typeof fromState === 'boolean') {
+            lhsMatch = fromState ? TRUE_BOOLEAN_VALUES.has(lhs) : FALSE_BOOLEAN_VALUES.has(lhs);
+        }
+        if (!rhsMatch && RHS_MATCH_BOOLEAN && typeof toState === 'boolean') {
+            rhsMatch = toState ? TRUE_BOOLEAN_VALUES.has(rhs) : FALSE_BOOLEAN_VALUES.has(rhs);
+        }
+        return lhsMatch && rhsMatch;
+    };
+}
+
+const SELF_TOKEN = ':self';
+const SELF_TOKEN_REGEX = /* @__PURE__ */ new RegExp(`s*${SELF_TOKEN}s*,?`, 'g');
+/*
+ * [Validation]
+ * The visitor code below will traverse the animation AST generated by the animation verb functions
+ * (the output is a tree of objects) and attempt to perform a series of validations on the data. The
+ * following corner-cases will be validated:
+ *
+ * 1. Overlap of animations
+ * Given that a CSS property cannot be animated in more than one place at the same time, it's
+ * important that this behavior is detected and validated. The way in which this occurs is that
+ * each time a style property is examined, a string-map containing the property will be updated with
+ * the start and end times for when the property is used within an animation step.
+ *
+ * If there are two or more parallel animations that are currently running (these are invoked by the
+ * group()) on the same element then the validator will throw an error. Since the start/end timing
+ * values are collected for each property then if the current animation step is animating the same
+ * property and its timing values fall anywhere into the window of time that the property is
+ * currently being animated within then this is what causes an error.
+ *
+ * 2. Timing values
+ * The validator will validate to see if a timing value of `duration delay easing` or
+ * `durationNumber` is valid or not.
+ *
+ * (note that upon validation the code below will replace the timing data with an object containing
+ * {duration,delay,easing}.
+ *
+ * 3. Offset Validation
+ * Each of the style() calls are allowed to have an offset value when placed inside of keyframes().
+ * Offsets within keyframes() are considered valid when:
+ *
+ *   - No offsets are used at all
+ *   - Each style() entry contains an offset value
+ *   - Each offset is between 0 and 1
+ *   - Each offset is greater to or equal than the previous one
+ *
+ * Otherwise an error will be thrown.
+ */
+function buildAnimationAst(driver, metadata, errors, warnings) {
+    return new AnimationAstBuilderVisitor(driver).build(metadata, errors, warnings);
+}
+const ROOT_SELECTOR = '';
+class AnimationAstBuilderVisitor {
+    _driver;
+    constructor(_driver) {
+        this._driver = _driver;
+    }
+    build(metadata, errors, warnings) {
+        const context = new AnimationAstBuilderContext(errors);
+        this._resetContextStyleTimingState(context);
+        const ast = (visitDslNode(this, normalizeAnimationEntry(metadata), context));
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            if (context.unsupportedCSSPropertiesFound.size) {
+                pushUnrecognizedPropertiesWarning(warnings, [
+                    ...context.unsupportedCSSPropertiesFound.keys(),
+                ]);
+            }
+        }
+        return ast;
+    }
+    _resetContextStyleTimingState(context) {
+        context.currentQuerySelector = ROOT_SELECTOR;
+        context.collectedStyles = new Map();
+        context.collectedStyles.set(ROOT_SELECTOR, new Map());
+        context.currentTime = 0;
+    }
+    visitTrigger(metadata, context) {
+        let queryCount = (context.queryCount = 0);
+        let depCount = (context.depCount = 0);
+        const states = [];
+        const transitions = [];
+        if (metadata.name.charAt(0) == '@') {
+            context.errors.push(invalidTrigger());
+        }
+        metadata.definitions.forEach((def) => {
+            this._resetContextStyleTimingState(context);
+            if (def.type == AnimationMetadataType.State) {
+                const stateDef = def;
+                const name = stateDef.name;
+                name
+                    .toString()
+                    .split(/\s*,\s*/)
+                    .forEach((n) => {
+                    stateDef.name = n;
+                    states.push(this.visitState(stateDef, context));
+                });
+                stateDef.name = name;
+            }
+            else if (def.type == AnimationMetadataType.Transition) {
+                const transition = this.visitTransition(def, context);
+                queryCount += transition.queryCount;
+                depCount += transition.depCount;
+                transitions.push(transition);
+            }
+            else {
+                context.errors.push(invalidDefinition());
+            }
+        });
+        return {
+            type: AnimationMetadataType.Trigger,
+            name: metadata.name,
+            states,
+            transitions,
+            queryCount,
+            depCount,
+            options: null,
+        };
+    }
+    visitState(metadata, context) {
+        const styleAst = this.visitStyle(metadata.styles, context);
+        const astParams = (metadata.options && metadata.options.params) || null;
+        if (styleAst.containsDynamicStyles) {
+            const missingSubs = new Set();
+            const params = astParams || {};
+            styleAst.styles.forEach((style) => {
+                if (style instanceof Map) {
+                    style.forEach((value) => {
+                        extractStyleParams(value).forEach((sub) => {
+                            if (!params.hasOwnProperty(sub)) {
+                                missingSubs.add(sub);
+                            }
+                        });
+                    });
+                }
+            });
+            if (missingSubs.size) {
+                context.errors.push(invalidState(metadata.name, [...missingSubs.values()]));
+            }
+        }
+        return {
+            type: AnimationMetadataType.State,
+            name: metadata.name,
+            style: styleAst,
+            options: astParams ? { params: astParams } : null,
+        };
+    }
+    visitTransition(metadata, context) {
+        context.queryCount = 0;
+        context.depCount = 0;
+        const animation = visitDslNode(this, normalizeAnimationEntry(metadata.animation), context);
+        const matchers = parseTransitionExpr(metadata.expr, context.errors);
+        return {
+            type: AnimationMetadataType.Transition,
+            matchers,
+            animation,
+            queryCount: context.queryCount,
+            depCount: context.depCount,
+            options: normalizeAnimationOptions(metadata.options),
+        };
+    }
+    visitSequence(metadata, context) {
+        return {
+            type: AnimationMetadataType.Sequence,
+            steps: metadata.steps.map((s) => visitDslNode(this, s, context)),
+            options: normalizeAnimationOptions(metadata.options),
+        };
+    }
+    visitGroup(metadata, context) {
+        const currentTime = context.currentTime;
+        let furthestTime = 0;
+        const steps = metadata.steps.map((step) => {
+            context.currentTime = currentTime;
+            const innerAst = visitDslNode(this, step, context);
+            furthestTime = Math.max(furthestTime, context.currentTime);
+            return innerAst;
+        });
+        context.currentTime = furthestTime;
+        return {
+            type: AnimationMetadataType.Group,
+            steps,
+            options: normalizeAnimationOptions(metadata.options),
+        };
+    }
+    visitAnimate(metadata, context) {
+        const timingAst = constructTimingAst(metadata.timings, context.errors);
+        context.currentAnimateTimings = timingAst;
+        let styleAst;
+        let styleMetadata = metadata.styles
+            ? metadata.styles
+            : style({});
+        if (styleMetadata.type == AnimationMetadataType.Keyframes) {
+            styleAst = this.visitKeyframes(styleMetadata, context);
+        }
+        else {
+            let styleMetadata = metadata.styles;
+            let isEmpty = false;
+            if (!styleMetadata) {
+                isEmpty = true;
+                const newStyleData = {};
+                if (timingAst.easing) {
+                    newStyleData['easing'] = timingAst.easing;
+                }
+                styleMetadata = style(newStyleData);
+            }
+            context.currentTime += timingAst.duration + timingAst.delay;
+            const _styleAst = this.visitStyle(styleMetadata, context);
+            _styleAst.isEmptyStep = isEmpty;
+            styleAst = _styleAst;
+        }
+        context.currentAnimateTimings = null;
+        return {
+            type: AnimationMetadataType.Animate,
+            timings: timingAst,
+            style: styleAst,
+            options: null,
+        };
+    }
+    visitStyle(metadata, context) {
+        const ast = this._makeStyleAst(metadata, context);
+        this._validateStyleAst(ast, context);
+        return ast;
+    }
+    _makeStyleAst(metadata, context) {
+        const styles = [];
+        const metadataStyles = Array.isArray(metadata.styles) ? metadata.styles : [metadata.styles];
+        for (let styleTuple of metadataStyles) {
+            if (typeof styleTuple === 'string') {
+                if (styleTuple === AUTO_STYLE) {
+                    styles.push(styleTuple);
+                }
+                else {
+                    context.errors.push(invalidStyleValue(styleTuple));
+                }
+            }
+            else {
+                styles.push(new Map(Object.entries(styleTuple)));
+            }
+        }
+        let containsDynamicStyles = false;
+        let collectedEasing = null;
+        styles.forEach((styleData) => {
+            if (styleData instanceof Map) {
+                if (styleData.has('easing')) {
+                    collectedEasing = styleData.get('easing');
+                    styleData.delete('easing');
+                }
+                if (!containsDynamicStyles) {
+                    for (let value of styleData.values()) {
+                        if (value.toString().indexOf(SUBSTITUTION_EXPR_START) >= 0) {
+                            containsDynamicStyles = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        });
+        return {
+            type: AnimationMetadataType.Style,
+            styles,
+            easing: collectedEasing,
+            offset: metadata.offset,
+            containsDynamicStyles,
+            options: null,
+        };
+    }
+    _validateStyleAst(ast, context) {
+        const timings = context.currentAnimateTimings;
+        let endTime = context.currentTime;
+        let startTime = context.currentTime;
+        if (timings && startTime > 0) {
+            startTime -= timings.duration + timings.delay;
+        }
+        ast.styles.forEach((tuple) => {
+            if (typeof tuple === 'string')
+                return;
+            tuple.forEach((value, prop) => {
+                if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                    if (!this._driver.validateStyleProperty(prop)) {
+                        tuple.delete(prop);
+                        context.unsupportedCSSPropertiesFound.add(prop);
+                        return;
+                    }
+                }
+                // This is guaranteed to have a defined Map at this querySelector location making it
+                // safe to add the assertion here. It is set as a default empty map in prior methods.
+                const collectedStyles = context.collectedStyles.get(context.currentQuerySelector);
+                const collectedEntry = collectedStyles.get(prop);
+                let updateCollectedStyle = true;
+                if (collectedEntry) {
+                    if (startTime != endTime &&
+                        startTime >= collectedEntry.startTime &&
+                        endTime <= collectedEntry.endTime) {
+                        context.errors.push(invalidParallelAnimation(prop, collectedEntry.startTime, collectedEntry.endTime, startTime, endTime));
+                        updateCollectedStyle = false;
+                    }
+                    // we always choose the smaller start time value since we
+                    // want to have a record of the entire animation window where
+                    // the style property is being animated in between
+                    startTime = collectedEntry.startTime;
+                }
+                if (updateCollectedStyle) {
+                    collectedStyles.set(prop, { startTime, endTime });
+                }
+                if (context.options) {
+                    validateStyleParams(value, context.options, context.errors);
+                }
+            });
+        });
+    }
+    visitKeyframes(metadata, context) {
+        const ast = { type: AnimationMetadataType.Keyframes, styles: [], options: null };
+        if (!context.currentAnimateTimings) {
+            context.errors.push(invalidKeyframes());
+            return ast;
+        }
+        const MAX_KEYFRAME_OFFSET = 1;
+        let totalKeyframesWithOffsets = 0;
+        const offsets = [];
+        let offsetsOutOfOrder = false;
+        let keyframesOutOfRange = false;
+        let previousOffset = 0;
+        const keyframes = metadata.steps.map((styles) => {
+            const style = this._makeStyleAst(styles, context);
+            let offsetVal = style.offset != null ? style.offset : consumeOffset(style.styles);
+            let offset = 0;
+            if (offsetVal != null) {
+                totalKeyframesWithOffsets++;
+                offset = style.offset = offsetVal;
+            }
+            keyframesOutOfRange = keyframesOutOfRange || offset < 0 || offset > 1;
+            offsetsOutOfOrder = offsetsOutOfOrder || offset < previousOffset;
+            previousOffset = offset;
+            offsets.push(offset);
+            return style;
+        });
+        if (keyframesOutOfRange) {
+            context.errors.push(invalidOffset());
+        }
+        if (offsetsOutOfOrder) {
+            context.errors.push(keyframeOffsetsOutOfOrder());
+        }
+        const length = metadata.steps.length;
+        let generatedOffset = 0;
+        if (totalKeyframesWithOffsets > 0 && totalKeyframesWithOffsets < length) {
+            context.errors.push(keyframesMissingOffsets());
+        }
+        else if (totalKeyframesWithOffsets == 0) {
+            generatedOffset = MAX_KEYFRAME_OFFSET / (length - 1);
+        }
+        const limit = length - 1;
+        const currentTime = context.currentTime;
+        const currentAnimateTimings = context.currentAnimateTimings;
+        const animateDuration = currentAnimateTimings.duration;
+        keyframes.forEach((kf, i) => {
+            const offset = generatedOffset > 0 ? (i == limit ? 1 : generatedOffset * i) : offsets[i];
+            const durationUpToThisFrame = offset * animateDuration;
+            context.currentTime = currentTime + currentAnimateTimings.delay + durationUpToThisFrame;
+            currentAnimateTimings.duration = durationUpToThisFrame;
+            this._validateStyleAst(kf, context);
+            kf.offset = offset;
+            ast.styles.push(kf);
+        });
+        return ast;
+    }
+    visitReference(metadata, context) {
+        return {
+            type: AnimationMetadataType.Reference,
+            animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context),
+            options: normalizeAnimationOptions(metadata.options),
+        };
+    }
+    visitAnimateChild(metadata, context) {
+        context.depCount++;
+        return {
+            type: AnimationMetadataType.AnimateChild,
+            options: normalizeAnimationOptions(metadata.options),
+        };
+    }
+    visitAnimateRef(metadata, context) {
+        return {
+            type: AnimationMetadataType.AnimateRef,
+            animation: this.visitReference(metadata.animation, context),
+            options: normalizeAnimationOptions(metadata.options),
+        };
+    }
+    visitQuery(metadata, context) {
+        const parentSelector = context.currentQuerySelector;
+        const options = (metadata.options || {});
+        context.queryCount++;
+        context.currentQuery = metadata;
+        const [selector, includeSelf] = normalizeSelector(metadata.selector);
+        context.currentQuerySelector = parentSelector.length
+            ? parentSelector + ' ' + selector
+            : selector;
+        getOrSetDefaultValue(context.collectedStyles, context.currentQuerySelector, new Map());
+        const animation = visitDslNode(this, normalizeAnimationEntry(metadata.animation), context);
+        context.currentQuery = null;
+        context.currentQuerySelector = parentSelector;
+        return {
+            type: AnimationMetadataType.Query,
+            selector,
+            limit: options.limit || 0,
+            optional: !!options.optional,
+            includeSelf,
+            animation,
+            originalSelector: metadata.selector,
+            options: normalizeAnimationOptions(metadata.options),
+        };
+    }
+    visitStagger(metadata, context) {
+        if (!context.currentQuery) {
+            context.errors.push(invalidStagger());
+        }
+        const timings = metadata.timings === 'full'
+            ? { duration: 0, delay: 0, easing: 'full' }
+            : resolveTiming(metadata.timings, context.errors, true);
+        return {
+            type: AnimationMetadataType.Stagger,
+            animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context),
+            timings,
+            options: null,
+        };
+    }
+}
+function normalizeSelector(selector) {
+    const hasAmpersand = selector.split(/\s*,\s*/).find((token) => token == SELF_TOKEN)
+        ? true
+        : false;
+    if (hasAmpersand) {
+        selector = selector.replace(SELF_TOKEN_REGEX, '');
+    }
+    // Note: the :enter and :leave aren't normalized here since those
+    // selectors are filled in at runtime during timeline building
+    selector = selector
+        .replace(/@\*/g, NG_TRIGGER_SELECTOR)
+        .replace(/@\w+/g, (match) => NG_TRIGGER_SELECTOR + '-' + match.slice(1))
+        .replace(/:animating/g, NG_ANIMATING_SELECTOR);
+    return [selector, hasAmpersand];
+}
+function normalizeParams(obj) {
+    return obj ? { ...obj } : null;
+}
+class AnimationAstBuilderContext {
+    errors;
+    queryCount = 0;
+    depCount = 0;
+    currentTransition = null;
+    currentQuery = null;
+    currentQuerySelector = null;
+    currentAnimateTimings = null;
+    currentTime = 0;
+    collectedStyles = new Map();
+    options = null;
+    unsupportedCSSPropertiesFound = new Set();
+    constructor(errors) {
+        this.errors = errors;
+    }
+}
+function consumeOffset(styles) {
+    if (typeof styles == 'string')
+        return null;
+    let offset = null;
+    if (Array.isArray(styles)) {
+        styles.forEach((styleTuple) => {
+            if (styleTuple instanceof Map && styleTuple.has('offset')) {
+                const obj = styleTuple;
+                offset = parseFloat(obj.get('offset'));
+                obj.delete('offset');
+            }
+        });
+    }
+    else if (styles instanceof Map && styles.has('offset')) {
+        const obj = styles;
+        offset = parseFloat(obj.get('offset'));
+        obj.delete('offset');
+    }
+    return offset;
+}
+function constructTimingAst(value, errors) {
+    if (value.hasOwnProperty('duration')) {
+        return value;
+    }
+    if (typeof value == 'number') {
+        const duration = resolveTiming(value, errors).duration;
+        return makeTimingAst(duration, 0, '');
+    }
+    const strValue = value;
+    const isDynamic = strValue.split(/\s+/).some((v) => v.charAt(0) == '{' && v.charAt(1) == '{');
+    if (isDynamic) {
+        const ast = makeTimingAst(0, 0, '');
+        ast.dynamic = true;
+        ast.strValue = strValue;
+        return ast;
+    }
+    const timings = resolveTiming(strValue, errors);
+    return makeTimingAst(timings.duration, timings.delay, timings.easing);
+}
+function normalizeAnimationOptions(options) {
+    if (options) {
+        options = { ...options };
+        if (options['params']) {
+            options['params'] = normalizeParams(options['params']);
+        }
+    }
+    else {
+        options = {};
+    }
+    return options;
+}
+function makeTimingAst(duration, delay, easing) {
+    return { duration, delay, easing };
+}
+
+function createTimelineInstruction(element, keyframes, preStyleProps, postStyleProps, duration, delay, easing = null, subTimeline = false) {
+    return {
+        type: 1 /* AnimationTransitionInstructionType.TimelineAnimation */,
+        element,
+        keyframes,
+        preStyleProps,
+        postStyleProps,
+        duration,
+        delay,
+        totalTime: duration + delay,
+        easing,
+        subTimeline,
+    };
+}
+
+class ElementInstructionMap {
+    _map = new Map();
+    get(element) {
+        return this._map.get(element) || [];
+    }
+    append(element, instructions) {
+        let existingInstructions = this._map.get(element);
+        if (!existingInstructions) {
+            this._map.set(element, (existingInstructions = []));
+        }
+        existingInstructions.push(...instructions);
+    }
+    has(element) {
+        return this._map.has(element);
+    }
+    clear() {
+        this._map.clear();
+    }
+}
+
+const ONE_FRAME_IN_MILLISECONDS = 1;
+const ENTER_TOKEN = ':enter';
+const ENTER_TOKEN_REGEX = /* @__PURE__ */ new RegExp(ENTER_TOKEN, 'g');
+const LEAVE_TOKEN = ':leave';
+const LEAVE_TOKEN_REGEX = /* @__PURE__ */ new RegExp(LEAVE_TOKEN, 'g');
+/*
+ * The code within this file aims to generate web-animations-compatible keyframes from Angular's
+ * animation DSL code.
+ *
+ * The code below will be converted from:
+ *
+ * ```ts
+ * sequence([
+ *   style({ opacity: 0 }),
+ *   animate(1000, style({ opacity: 0 }))
+ * ])
+ * ```
+ *
+ * To:
+ * ```ts
+ * keyframes = [{ opacity: 0, offset: 0 }, { opacity: 1, offset: 1 }]
+ * duration = 1000
+ * delay = 0
+ * easing = ''
+ * ```
+ *
+ * For this operation to cover the combination of animation verbs (style, animate, group, etc...) a
+ * combination of AST traversal and merge-sort-like algorithms are used.
+ *
+ * [AST Traversal]
+ * Each of the animation verbs, when executed, will return an string-map object representing what
+ * type of action it is (style, animate, group, etc...) and the data associated with it. This means
+ * that when functional composition mix of these functions is evaluated (like in the example above)
+ * then it will end up producing a tree of objects representing the animation itself.
+ *
+ * When this animation object tree is processed by the visitor code below it will visit each of the
+ * verb statements within the visitor. And during each visit it will build the context of the
+ * animation keyframes by interacting with the `TimelineBuilder`.
+ *
+ * [TimelineBuilder]
+ * This class is responsible for tracking the styles and building a series of keyframe objects for a
+ * timeline between a start and end time. The builder starts off with an initial timeline and each
+ * time the AST comes across a `group()`, `keyframes()` or a combination of the two within a
+ * `sequence()` then it will generate a sub timeline for each step as well as a new one after
+ * they are complete.
+ *
+ * As the AST is traversed, the timing state on each of the timelines will be incremented. If a sub
+ * timeline was created (based on one of the cases above) then the parent timeline will attempt to
+ * merge the styles used within the sub timelines into itself (only with group() this will happen).
+ * This happens with a merge operation (much like how the merge works in mergeSort) and it will only
+ * copy the most recently used styles from the sub timelines into the parent timeline. This ensures
+ * that if the styles are used later on in another phase of the animation then they will be the most
+ * up-to-date values.
+ *
+ * [How Missing Styles Are Updated]
+ * Each timeline has a `backFill` property which is responsible for filling in new styles into
+ * already processed keyframes if a new style shows up later within the animation sequence.
+ *
+ * ```ts
+ * sequence([
+ *   style({ width: 0 }),
+ *   animate(1000, style({ width: 100 })),
+ *   animate(1000, style({ width: 200 })),
+ *   animate(1000, style({ width: 300 }))
+ *   animate(1000, style({ width: 400, height: 400 })) // notice how `height` doesn't exist anywhere
+ * else
+ * ])
+ * ```
+ *
+ * What is happening here is that the `height` value is added later in the sequence, but is missing
+ * from all previous animation steps. Therefore when a keyframe is created it would also be missing
+ * from all previous keyframes up until where it is first used. For the timeline keyframe generation
+ * to properly fill in the style it will place the previous value (the value from the parent
+ * timeline) or a default value of `*` into the backFill map.
+ *
+ * When a sub-timeline is created it will have its own backFill property. This is done so that
+ * styles present within the sub-timeline do not accidentally seep into the previous/future timeline
+ * keyframes
+ *
+ * [Validation]
+ * The code in this file is not responsible for validation. That functionality happens with within
+ * the `AnimationValidatorVisitor` code.
+ */
+function buildAnimationTimelines(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles = new Map(), finalStyles = new Map(), options, subInstructions, errors = []) {
+    return new AnimationTimelineBuilderVisitor().buildKeyframes(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors);
+}
+class AnimationTimelineBuilderVisitor {
+    buildKeyframes(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors = []) {
+        subInstructions = subInstructions || new ElementInstructionMap();
+        const context = new AnimationTimelineContext(driver, rootElement, subInstructions, enterClassName, leaveClassName, errors, []);
+        context.options = options;
+        const delay = options.delay ? resolveTimingValue(options.delay) : 0;
+        context.currentTimeline.delayNextStep(delay);
+        context.currentTimeline.setStyles([startingStyles], null, context.errors, options);
+        visitDslNode(this, ast, context);
+        // this checks to see if an actual animation happened
+        const timelines = context.timelines.filter((timeline) => timeline.containsAnimation());
+        // note: we just want to apply the final styles for the rootElement, so we do not
+        //       just apply the styles to the last timeline but the last timeline which
+        //       element is the root one (basically `*`-styles are replaced with the actual
+        //       state style values only for the root element)
+        if (timelines.length && finalStyles.size) {
+            let lastRootTimeline;
+            for (let i = timelines.length - 1; i >= 0; i--) {
+                const timeline = timelines[i];
+                if (timeline.element === rootElement) {
+                    lastRootTimeline = timeline;
+                    break;
+                }
+            }
+            if (lastRootTimeline && !lastRootTimeline.allowOnlyTimelineStyles()) {
+                lastRootTimeline.setStyles([finalStyles], null, context.errors, options);
+            }
+        }
+        return timelines.length
+            ? timelines.map((timeline) => timeline.buildKeyframes())
+            : [createTimelineInstruction(rootElement, [], [], [], 0, delay, '', false)];
+    }
+    visitTrigger(ast, context) {
+        // these values are not visited in this AST
+    }
+    visitState(ast, context) {
+        // these values are not visited in this AST
+    }
+    visitTransition(ast, context) {
+        // these values are not visited in this AST
+    }
+    visitAnimateChild(ast, context) {
+        const elementInstructions = context.subInstructions.get(context.element);
+        if (elementInstructions) {
+            const innerContext = context.createSubContext(ast.options);
+            const startTime = context.currentTimeline.currentTime;
+            const endTime = this._visitSubInstructions(elementInstructions, innerContext, innerContext.options);
+            if (startTime != endTime) {
+                // we do this on the upper context because we created a sub context for
+                // the sub child animations
+                context.transformIntoNewTimeline(endTime);
+            }
+        }
+        context.previousNode = ast;
+    }
+    visitAnimateRef(ast, context) {
+        const innerContext = context.createSubContext(ast.options);
+        innerContext.transformIntoNewTimeline();
+        this._applyAnimationRefDelays([ast.options, ast.animation.options], context, innerContext);
+        this.visitReference(ast.animation, innerContext);
+        context.transformIntoNewTimeline(innerContext.currentTimeline.currentTime);
+        context.previousNode = ast;
+    }
+    _applyAnimationRefDelays(animationsRefsOptions, context, innerContext) {
+        for (const animationRefOptions of animationsRefsOptions) {
+            const animationDelay = animationRefOptions?.delay;
+            if (animationDelay) {
+                const animationDelayValue = typeof animationDelay === 'number'
+                    ? animationDelay
+                    : resolveTimingValue(interpolateParams(animationDelay, animationRefOptions?.params ?? {}, context.errors));
+                innerContext.delayNextStep(animationDelayValue);
+            }
+        }
+    }
+    _visitSubInstructions(instructions, context, options) {
+        const startTime = context.currentTimeline.currentTime;
+        let furthestTime = startTime;
+        // this is a special-case for when a user wants to skip a sub
+        // animation from being fired entirely.
+        const duration = options.duration != null ? resolveTimingValue(options.duration) : null;
+        const delay = options.delay != null ? resolveTimingValue(options.delay) : null;
+        if (duration !== 0) {
+            instructions.forEach((instruction) => {
+                const instructionTimings = context.appendInstructionToTimeline(instruction, duration, delay);
+                furthestTime = Math.max(furthestTime, instructionTimings.duration + instructionTimings.delay);
+            });
+        }
+        return furthestTime;
+    }
+    visitReference(ast, context) {
+        context.updateOptions(ast.options, true);
+        visitDslNode(this, ast.animation, context);
+        context.previousNode = ast;
+    }
+    visitSequence(ast, context) {
+        const subContextCount = context.subContextCount;
+        let ctx = context;
+        const options = ast.options;
+        if (options && (options.params || options.delay)) {
+            ctx = context.createSubContext(options);
+            ctx.transformIntoNewTimeline();
+            if (options.delay != null) {
+                if (ctx.previousNode.type == AnimationMetadataType.Style) {
+                    ctx.currentTimeline.snapshotCurrentStyles();
+                    ctx.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+                }
+                const delay = resolveTimingValue(options.delay);
+                ctx.delayNextStep(delay);
+            }
+        }
+        if (ast.steps.length) {
+            ast.steps.forEach((s) => visitDslNode(this, s, ctx));
+            // this is here just in case the inner steps only contain or end with a style() call
+            ctx.currentTimeline.applyStylesToKeyframe();
+            // this means that some animation function within the sequence
+            // ended up creating a sub timeline (which means the current
+            // timeline cannot overlap with the contents of the sequence)
+            if (ctx.subContextCount > subContextCount) {
+                ctx.transformIntoNewTimeline();
+            }
+        }
+        context.previousNode = ast;
+    }
+    visitGroup(ast, context) {
+        const innerTimelines = [];
+        let furthestTime = context.currentTimeline.currentTime;
+        const delay = ast.options && ast.options.delay ? resolveTimingValue(ast.options.delay) : 0;
+        ast.steps.forEach((s) => {
+            const innerContext = context.createSubContext(ast.options);
+            if (delay) {
+                innerContext.delayNextStep(delay);
+            }
+            visitDslNode(this, s, innerContext);
+            furthestTime = Math.max(furthestTime, innerContext.currentTimeline.currentTime);
+            innerTimelines.push(innerContext.currentTimeline);
+        });
+        // this operation is run after the AST loop because otherwise
+        // if the parent timeline's collected styles were updated then
+        // it would pass in invalid data into the new-to-be forked items
+        innerTimelines.forEach((timeline) => context.currentTimeline.mergeTimelineCollectedStyles(timeline));
+        context.transformIntoNewTimeline(furthestTime);
+        context.previousNode = ast;
+    }
+    _visitTiming(ast, context) {
+        if (ast.dynamic) {
+            const strValue = ast.strValue;
+            const timingValue = context.params
+                ? interpolateParams(strValue, context.params, context.errors)
+                : strValue;
+            return resolveTiming(timingValue, context.errors);
+        }
+        else {
+            return { duration: ast.duration, delay: ast.delay, easing: ast.easing };
+        }
+    }
+    visitAnimate(ast, context) {
+        const timings = (context.currentAnimateTimings = this._visitTiming(ast.timings, context));
+        const timeline = context.currentTimeline;
+        if (timings.delay) {
+            context.incrementTime(timings.delay);
+            timeline.snapshotCurrentStyles();
+        }
+        const style = ast.style;
+        if (style.type == AnimationMetadataType.Keyframes) {
+            this.visitKeyframes(style, context);
+        }
+        else {
+            context.incrementTime(timings.duration);
+            this.visitStyle(style, context);
+            timeline.applyStylesToKeyframe();
+        }
+        context.currentAnimateTimings = null;
+        context.previousNode = ast;
+    }
+    visitStyle(ast, context) {
+        const timeline = context.currentTimeline;
+        const timings = context.currentAnimateTimings;
+        // this is a special case for when a style() call
+        // directly follows  an animate() call (but not inside of an animate() call)
+        if (!timings && timeline.hasCurrentStyleProperties()) {
+            timeline.forwardFrame();
+        }
+        const easing = (timings && timings.easing) || ast.easing;
+        if (ast.isEmptyStep) {
+            timeline.applyEmptyStep(easing);
+        }
+        else {
+            timeline.setStyles(ast.styles, easing, context.errors, context.options);
+        }
+        context.previousNode = ast;
+    }
+    visitKeyframes(ast, context) {
+        const currentAnimateTimings = context.currentAnimateTimings;
+        const startTime = context.currentTimeline.duration;
+        const duration = currentAnimateTimings.duration;
+        const innerContext = context.createSubContext();
+        const innerTimeline = innerContext.currentTimeline;
+        innerTimeline.easing = currentAnimateTimings.easing;
+        ast.styles.forEach((step) => {
+            const offset = step.offset || 0;
+            innerTimeline.forwardTime(offset * duration);
+            innerTimeline.setStyles(step.styles, step.easing, context.errors, context.options);
+            innerTimeline.applyStylesToKeyframe();
+        });
+        // this will ensure that the parent timeline gets all the styles from
+        // the child even if the new timeline below is not used
+        context.currentTimeline.mergeTimelineCollectedStyles(innerTimeline);
+        // we do this because the window between this timeline and the sub timeline
+        // should ensure that the styles within are exactly the same as they were before
+        context.transformIntoNewTimeline(startTime + duration);
+        context.previousNode = ast;
+    }
+    visitQuery(ast, context) {
+        // in the event that the first step before this is a style step we need
+        // to ensure the styles are applied before the children are animated
+        const startTime = context.currentTimeline.currentTime;
+        const options = (ast.options || {});
+        const delay = options.delay ? resolveTimingValue(options.delay) : 0;
+        if (delay &&
+            (context.previousNode.type === AnimationMetadataType.Style ||
+                (startTime == 0 && context.currentTimeline.hasCurrentStyleProperties()))) {
+            context.currentTimeline.snapshotCurrentStyles();
+            context.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+        }
+        let furthestTime = startTime;
+        const elms = context.invokeQuery(ast.selector, ast.originalSelector, ast.limit, ast.includeSelf, options.optional ? true : false, context.errors);
+        context.currentQueryTotal = elms.length;
+        let sameElementTimeline = null;
+        elms.forEach((element, i) => {
+            context.currentQueryIndex = i;
+            const innerContext = context.createSubContext(ast.options, element);
+            if (delay) {
+                innerContext.delayNextStep(delay);
+            }
+            if (element === context.element) {
+                sameElementTimeline = innerContext.currentTimeline;
+            }
+            visitDslNode(this, ast.animation, innerContext);
+            // this is here just incase the inner steps only contain or end
+            // with a style() call (which is here to signal that this is a preparatory
+            // call to style an element before it is animated again)
+            innerContext.currentTimeline.applyStylesToKeyframe();
+            const endTime = innerContext.currentTimeline.currentTime;
+            furthestTime = Math.max(furthestTime, endTime);
+        });
+        context.currentQueryIndex = 0;
+        context.currentQueryTotal = 0;
+        context.transformIntoNewTimeline(furthestTime);
+        if (sameElementTimeline) {
+            context.currentTimeline.mergeTimelineCollectedStyles(sameElementTimeline);
+            context.currentTimeline.snapshotCurrentStyles();
+        }
+        context.previousNode = ast;
+    }
+    visitStagger(ast, context) {
+        const parentContext = context.parentContext;
+        const tl = context.currentTimeline;
+        const timings = ast.timings;
+        const duration = Math.abs(timings.duration);
+        const maxTime = duration * (context.currentQueryTotal - 1);
+        let delay = duration * context.currentQueryIndex;
+        let staggerTransformer = timings.duration < 0 ? 'reverse' : timings.easing;
+        switch (staggerTransformer) {
+            case 'reverse':
+                delay = maxTime - delay;
+                break;
+            case 'full':
+                delay = parentContext.currentStaggerTime;
+                break;
+        }
+        const timeline = context.currentTimeline;
+        if (delay) {
+            timeline.delayNextStep(delay);
+        }
+        const startingTime = timeline.currentTime;
+        visitDslNode(this, ast.animation, context);
+        context.previousNode = ast;
+        // time = duration + delay
+        // the reason why this computation is so complex is because
+        // the inner timeline may either have a delay value or a stretched
+        // keyframe depending on if a subtimeline is not used or is used.
+        parentContext.currentStaggerTime =
+            tl.currentTime - startingTime + (tl.startTime - parentContext.currentTimeline.startTime);
+    }
+}
+const DEFAULT_NOOP_PREVIOUS_NODE = {};
+class AnimationTimelineContext {
+    _driver;
+    element;
+    subInstructions;
+    _enterClassName;
+    _leaveClassName;
+    errors;
+    timelines;
+    parentContext = null;
+    currentTimeline;
+    currentAnimateTimings = null;
+    previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+    subContextCount = 0;
+    options = {};
+    currentQueryIndex = 0;
+    currentQueryTotal = 0;
+    currentStaggerTime = 0;
+    constructor(_driver, element, subInstructions, _enterClassName, _leaveClassName, errors, timelines, initialTimeline) {
+        this._driver = _driver;
+        this.element = element;
+        this.subInstructions = subInstructions;
+        this._enterClassName = _enterClassName;
+        this._leaveClassName = _leaveClassName;
+        this.errors = errors;
+        this.timelines = timelines;
+        this.currentTimeline = initialTimeline || new TimelineBuilder(this._driver, element, 0);
+        timelines.push(this.currentTimeline);
+    }
+    get params() {
+        return this.options.params;
+    }
+    updateOptions(options, skipIfExists) {
+        if (!options)
+            return;
+        const newOptions = options;
+        let optionsToUpdate = this.options;
+        // NOTE: this will get patched up when other animation methods support duration overrides
+        if (newOptions.duration != null) {
+            optionsToUpdate.duration = resolveTimingValue(newOptions.duration);
+        }
+        if (newOptions.delay != null) {
+            optionsToUpdate.delay = resolveTimingValue(newOptions.delay);
+        }
+        const newParams = newOptions.params;
+        if (newParams) {
+            let paramsToUpdate = optionsToUpdate.params;
+            if (!paramsToUpdate) {
+                paramsToUpdate = this.options.params = {};
+            }
+            Object.keys(newParams).forEach((name) => {
+                if (!skipIfExists || !paramsToUpdate.hasOwnProperty(name)) {
+                    paramsToUpdate[name] = interpolateParams(newParams[name], paramsToUpdate, this.errors);
+                }
+            });
+        }
+    }
+    _copyOptions() {
+        const options = {};
+        if (this.options) {
+            const oldParams = this.options.params;
+            if (oldParams) {
+                const params = (options['params'] = {});
+                Object.keys(oldParams).forEach((name) => {
+                    params[name] = oldParams[name];
+                });
+            }
+        }
+        return options;
+    }
+    createSubContext(options = null, element, newTime) {
+        const target = element || this.element;
+        const context = new AnimationTimelineContext(this._driver, target, this.subInstructions, this._enterClassName, this._leaveClassName, this.errors, this.timelines, this.currentTimeline.fork(target, newTime || 0));
+        context.previousNode = this.previousNode;
+        context.currentAnimateTimings = this.currentAnimateTimings;
+        context.options = this._copyOptions();
+        context.updateOptions(options);
+        context.currentQueryIndex = this.currentQueryIndex;
+        context.currentQueryTotal = this.currentQueryTotal;
+        context.parentContext = this;
+        this.subContextCount++;
+        return context;
+    }
+    transformIntoNewTimeline(newTime) {
+        this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+        this.currentTimeline = this.currentTimeline.fork(this.element, newTime);
+        this.timelines.push(this.currentTimeline);
+        return this.currentTimeline;
+    }
+    appendInstructionToTimeline(instruction, duration, delay) {
+        const updatedTimings = {
+            duration: duration != null ? duration : instruction.duration,
+            delay: this.currentTimeline.currentTime + (delay != null ? delay : 0) + instruction.delay,
+            easing: '',
+        };
+        const builder = new SubTimelineBuilder(this._driver, instruction.element, instruction.keyframes, instruction.preStyleProps, instruction.postStyleProps, updatedTimings, instruction.stretchStartingKeyframe);
+        this.timelines.push(builder);
+        return updatedTimings;
+    }
+    incrementTime(time) {
+        this.currentTimeline.forwardTime(this.currentTimeline.duration + time);
+    }
+    delayNextStep(delay) {
+        // negative delays are not yet supported
+        if (delay > 0) {
+            this.currentTimeline.delayNextStep(delay);
+        }
+    }
+    invokeQuery(selector, originalSelector, limit, includeSelf, optional, errors) {
+        let results = [];
+        if (includeSelf) {
+            results.push(this.element);
+        }
+        if (selector.length > 0) {
+            // only if :self is used then the selector can be empty
+            selector = selector.replace(ENTER_TOKEN_REGEX, '.' + this._enterClassName);
+            selector = selector.replace(LEAVE_TOKEN_REGEX, '.' + this._leaveClassName);
+            const multi = limit != 1;
+            let elements = this._driver.query(this.element, selector, multi);
+            if (limit !== 0) {
+                elements =
+                    limit < 0
+                        ? elements.slice(elements.length + limit, elements.length)
+                        : elements.slice(0, limit);
+            }
+            results.push(...elements);
+        }
+        if (!optional && results.length == 0) {
+            errors.push(invalidQuery(originalSelector));
+        }
+        return results;
+    }
+}
+class TimelineBuilder {
+    _driver;
+    element;
+    startTime;
+    _elementTimelineStylesLookup;
+    duration = 0;
+    easing = null;
+    _previousKeyframe = new Map();
+    _currentKeyframe = new Map();
+    _keyframes = new Map();
+    _styleSummary = new Map();
+    _localTimelineStyles = new Map();
+    _globalTimelineStyles;
+    _pendingStyles = new Map();
+    _backFill = new Map();
+    _currentEmptyStepKeyframe = null;
+    constructor(_driver, element, startTime, _elementTimelineStylesLookup) {
+        this._driver = _driver;
+        this.element = element;
+        this.startTime = startTime;
+        this._elementTimelineStylesLookup = _elementTimelineStylesLookup;
+        if (!this._elementTimelineStylesLookup) {
+            this._elementTimelineStylesLookup = new Map();
+        }
+        this._globalTimelineStyles = this._elementTimelineStylesLookup.get(element);
+        if (!this._globalTimelineStyles) {
+            this._globalTimelineStyles = this._localTimelineStyles;
+            this._elementTimelineStylesLookup.set(element, this._localTimelineStyles);
+        }
+        this._loadKeyframe();
+    }
+    containsAnimation() {
+        switch (this._keyframes.size) {
+            case 0:
+                return false;
+            case 1:
+                return this.hasCurrentStyleProperties();
+            default:
+                return true;
+        }
+    }
+    hasCurrentStyleProperties() {
+        return this._currentKeyframe.size > 0;
+    }
+    get currentTime() {
+        return this.startTime + this.duration;
+    }
+    delayNextStep(delay) {
+        // in the event that a style() step is placed right before a stagger()
+        // and that style() step is the very first style() value in the animation
+        // then we need to make a copy of the keyframe [0, copy, 1] so that the delay
+        // properly applies the style() values to work with the stagger...
+        const hasPreStyleStep = this._keyframes.size === 1 && this._pendingStyles.size;
+        if (this.duration || hasPreStyleStep) {
+            this.forwardTime(this.currentTime + delay);
+            if (hasPreStyleStep) {
+                this.snapshotCurrentStyles();
+            }
+        }
+        else {
+            this.startTime += delay;
+        }
+    }
+    fork(element, currentTime) {
+        this.applyStylesToKeyframe();
+        return new TimelineBuilder(this._driver, element, currentTime || this.currentTime, this._elementTimelineStylesLookup);
+    }
+    _loadKeyframe() {
+        if (this._currentKeyframe) {
+            this._previousKeyframe = this._currentKeyframe;
+        }
+        this._currentKeyframe = this._keyframes.get(this.duration);
+        if (!this._currentKeyframe) {
+            this._currentKeyframe = new Map();
+            this._keyframes.set(this.duration, this._currentKeyframe);
+        }
+    }
+    forwardFrame() {
+        this.duration += ONE_FRAME_IN_MILLISECONDS;
+        this._loadKeyframe();
+    }
+    forwardTime(time) {
+        this.applyStylesToKeyframe();
+        this.duration = time;
+        this._loadKeyframe();
+    }
+    _updateStyle(prop, value) {
+        this._localTimelineStyles.set(prop, value);
+        this._globalTimelineStyles.set(prop, value);
+        this._styleSummary.set(prop, { time: this.currentTime, value });
+    }
+    allowOnlyTimelineStyles() {
+        return this._currentEmptyStepKeyframe !== this._currentKeyframe;
+    }
+    applyEmptyStep(easing) {
+        if (easing) {
+            this._previousKeyframe.set('easing', easing);
+        }
+        // special case for animate(duration):
+        // all missing styles are filled with a `*` value then
+        // if any destination styles are filled in later on the same
+        // keyframe then they will override the overridden styles
+        // We use `_globalTimelineStyles` here because there may be
+        // styles in previous keyframes that are not present in this timeline
+        for (let [prop, value] of this._globalTimelineStyles) {
+            this._backFill.set(prop, value || AUTO_STYLE);
+            this._currentKeyframe.set(prop, AUTO_STYLE);
+        }
+        this._currentEmptyStepKeyframe = this._currentKeyframe;
+    }
+    setStyles(input, easing, errors, options) {
+        if (easing) {
+            this._previousKeyframe.set('easing', easing);
+        }
+        const params = (options && options.params) || {};
+        const styles = flattenStyles(input, this._globalTimelineStyles);
+        for (let [prop, value] of styles) {
+            const val = interpolateParams(value, params, errors);
+            this._pendingStyles.set(prop, val);
+            if (!this._localTimelineStyles.has(prop)) {
+                this._backFill.set(prop, this._globalTimelineStyles.get(prop) ?? AUTO_STYLE);
+            }
+            this._updateStyle(prop, val);
+        }
+    }
+    applyStylesToKeyframe() {
+        if (this._pendingStyles.size == 0)
+            return;
+        this._pendingStyles.forEach((val, prop) => {
+            this._currentKeyframe.set(prop, val);
+        });
+        this._pendingStyles.clear();
+        this._localTimelineStyles.forEach((val, prop) => {
+            if (!this._currentKeyframe.has(prop)) {
+                this._currentKeyframe.set(prop, val);
+            }
+        });
+    }
+    snapshotCurrentStyles() {
+        for (let [prop, val] of this._localTimelineStyles) {
+            this._pendingStyles.set(prop, val);
+            this._updateStyle(prop, val);
+        }
+    }
+    getFinalKeyframe() {
+        return this._keyframes.get(this.duration);
+    }
+    get properties() {
+        const properties = [];
+        for (let prop in this._currentKeyframe) {
+            properties.push(prop);
+        }
+        return properties;
+    }
+    mergeTimelineCollectedStyles(timeline) {
+        timeline._styleSummary.forEach((details1, prop) => {
+            const details0 = this._styleSummary.get(prop);
+            if (!details0 || details1.time > details0.time) {
+                this._updateStyle(prop, details1.value);
+            }
+        });
+    }
+    buildKeyframes() {
+        this.applyStylesToKeyframe();
+        const preStyleProps = new Set();
+        const postStyleProps = new Set();
+        const isEmpty = this._keyframes.size === 1 && this.duration === 0;
+        let finalKeyframes = [];
+        this._keyframes.forEach((keyframe, time) => {
+            const finalKeyframe = new Map([...this._backFill, ...keyframe]);
+            finalKeyframe.forEach((value, prop) => {
+                if (value === _PRE_STYLE) {
+                    preStyleProps.add(prop);
+                }
+                else if (value === AUTO_STYLE) {
+                    postStyleProps.add(prop);
+                }
+            });
+            if (!isEmpty) {
+                finalKeyframe.set('offset', time / this.duration);
+            }
+            finalKeyframes.push(finalKeyframe);
+        });
+        const preProps = [...preStyleProps.values()];
+        const postProps = [...postStyleProps.values()];
+        // special case for a 0-second animation (which is designed just to place styles onscreen)
+        if (isEmpty) {
+            const kf0 = finalKeyframes[0];
+            const kf1 = new Map(kf0);
+            kf0.set('offset', 0);
+            kf1.set('offset', 1);
+            finalKeyframes = [kf0, kf1];
+        }
+        return createTimelineInstruction(this.element, finalKeyframes, preProps, postProps, this.duration, this.startTime, this.easing, false);
+    }
+}
+class SubTimelineBuilder extends TimelineBuilder {
+    keyframes;
+    preStyleProps;
+    postStyleProps;
+    _stretchStartingKeyframe;
+    timings;
+    constructor(driver, element, keyframes, preStyleProps, postStyleProps, timings, _stretchStartingKeyframe = false) {
+        super(driver, element, timings.delay);
+        this.keyframes = keyframes;
+        this.preStyleProps = preStyleProps;
+        this.postStyleProps = postStyleProps;
+        this._stretchStartingKeyframe = _stretchStartingKeyframe;
+        this.timings = { duration: timings.duration, delay: timings.delay, easing: timings.easing };
+    }
+    containsAnimation() {
+        return this.keyframes.length > 1;
+    }
+    buildKeyframes() {
+        let keyframes = this.keyframes;
+        let { delay, duration, easing } = this.timings;
+        if (this._stretchStartingKeyframe && delay) {
+            const newKeyframes = [];
+            const totalTime = duration + delay;
+            const startingGap = delay / totalTime;
+            // the original starting keyframe now starts once the delay is done
+            const newFirstKeyframe = new Map(keyframes[0]);
+            newFirstKeyframe.set('offset', 0);
+            newKeyframes.push(newFirstKeyframe);
+            const oldFirstKeyframe = new Map(keyframes[0]);
+            oldFirstKeyframe.set('offset', roundOffset(startingGap));
+            newKeyframes.push(oldFirstKeyframe);
+            /*
+              When the keyframe is stretched then it means that the delay before the animation
+              starts is gone. Instead the first keyframe is placed at the start of the animation
+              and it is then copied to where it starts when the original delay is over. This basically
+              means nothing animates during that delay, but the styles are still rendered. For this
+              to work the original offset values that exist in the original keyframes must be "warped"
+              so that they can take the new keyframe + delay into account.
+      
+              delay=1000, duration=1000, keyframes = 0 .5 1
+      
+              turns into
+      
+              delay=0, duration=2000, keyframes = 0 .33 .66 1
+             */
+            // offsets between 1 ... n -1 are all warped by the keyframe stretch
+            const limit = keyframes.length - 1;
+            for (let i = 1; i <= limit; i++) {
+                let kf = new Map(keyframes[i]);
+                const oldOffset = kf.get('offset');
+                const timeAtKeyframe = delay + oldOffset * duration;
+                kf.set('offset', roundOffset(timeAtKeyframe / totalTime));
+                newKeyframes.push(kf);
+            }
+            // the new starting keyframe should be added at the start
+            duration = totalTime;
+            delay = 0;
+            easing = '';
+            keyframes = newKeyframes;
+        }
+        return createTimelineInstruction(this.element, keyframes, this.preStyleProps, this.postStyleProps, duration, delay, easing, true);
+    }
+}
+function roundOffset(offset, decimalPoints = 3) {
+    const mult = Math.pow(10, decimalPoints - 1);
+    return Math.round(offset * mult) / mult;
+}
+function flattenStyles(input, allStyles) {
+    const styles = new Map();
+    let allProperties;
+    input.forEach((token) => {
+        if (token === '*') {
+            allProperties ??= allStyles.keys();
+            for (let prop of allProperties) {
+                styles.set(prop, AUTO_STYLE);
+            }
+        }
+        else {
+            for (let [prop, val] of token) {
+                styles.set(prop, val);
+            }
+        }
+    });
+    return styles;
+}
+
+function createTransitionInstruction(element, triggerName, fromState, toState, isRemovalTransition, fromStyles, toStyles, timelines, queriedElements, preStyleProps, postStyleProps, totalTime, errors) {
+    return {
+        type: 0 /* AnimationTransitionInstructionType.TransitionAnimation */,
+        element,
+        triggerName,
+        isRemovalTransition,
+        fromState,
+        fromStyles,
+        toState,
+        toStyles,
+        timelines,
+        queriedElements,
+        preStyleProps,
+        postStyleProps,
+        totalTime,
+        errors,
+    };
+}
+
+const EMPTY_OBJECT = {};
+class AnimationTransitionFactory {
+    _triggerName;
+    ast;
+    _stateStyles;
+    constructor(_triggerName, ast, _stateStyles) {
+        this._triggerName = _triggerName;
+        this.ast = ast;
+        this._stateStyles = _stateStyles;
+    }
+    match(currentState, nextState, element, params) {
+        return oneOrMoreTransitionsMatch(this.ast.matchers, currentState, nextState, element, params);
+    }
+    buildStyles(stateName, params, errors) {
+        let styler = this._stateStyles.get('*');
+        if (stateName !== undefined) {
+            styler = this._stateStyles.get(stateName?.toString()) || styler;
+        }
+        return styler ? styler.buildStyles(params, errors) : new Map();
+    }
+    build(driver, element, currentState, nextState, enterClassName, leaveClassName, currentOptions, nextOptions, subInstructions, skipAstBuild) {
+        const errors = [];
+        const transitionAnimationParams = (this.ast.options && this.ast.options.params) || EMPTY_OBJECT;
+        const currentAnimationParams = (currentOptions && currentOptions.params) || EMPTY_OBJECT;
+        const currentStateStyles = this.buildStyles(currentState, currentAnimationParams, errors);
+        const nextAnimationParams = (nextOptions && nextOptions.params) || EMPTY_OBJECT;
+        const nextStateStyles = this.buildStyles(nextState, nextAnimationParams, errors);
+        const queriedElements = new Set();
+        const preStyleMap = new Map();
+        const postStyleMap = new Map();
+        const isRemoval = nextState === 'void';
+        const animationOptions = {
+            params: applyParamDefaults(nextAnimationParams, transitionAnimationParams),
+            delay: this.ast.options?.delay,
+        };
+        const timelines = skipAstBuild
+            ? []
+            : buildAnimationTimelines(driver, element, this.ast.animation, enterClassName, leaveClassName, currentStateStyles, nextStateStyles, animationOptions, subInstructions, errors);
+        let totalTime = 0;
+        timelines.forEach((tl) => {
+            totalTime = Math.max(tl.duration + tl.delay, totalTime);
+        });
+        if (errors.length) {
+            return createTransitionInstruction(element, this._triggerName, currentState, nextState, isRemoval, currentStateStyles, nextStateStyles, [], [], preStyleMap, postStyleMap, totalTime, errors);
+        }
+        timelines.forEach((tl) => {
+            const elm = tl.element;
+            const preProps = getOrSetDefaultValue(preStyleMap, elm, new Set());
+            tl.preStyleProps.forEach((prop) => preProps.add(prop));
+            const postProps = getOrSetDefaultValue(postStyleMap, elm, new Set());
+            tl.postStyleProps.forEach((prop) => postProps.add(prop));
+            if (elm !== element) {
+                queriedElements.add(elm);
+            }
+        });
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            checkNonAnimatableInTimelines(timelines, this._triggerName, driver);
+        }
+        return createTransitionInstruction(element, this._triggerName, currentState, nextState, isRemoval, currentStateStyles, nextStateStyles, timelines, [...queriedElements.values()], preStyleMap, postStyleMap, totalTime);
+    }
+}
+/**
+ * Checks inside a set of timelines if they try to animate a css property which is not considered
+ * animatable, in that case it prints a warning on the console.
+ * Besides that the function doesn't have any other effect.
+ *
+ * Note: this check is done here after the timelines are built instead of doing on a lower level so
+ * that we can make sure that the warning appears only once per instruction (we can aggregate here
+ * all the issues instead of finding them separately).
+ *
+ * @param timelines The built timelines for the current instruction.
+ * @param triggerName The name of the trigger for the current instruction.
+ * @param driver Animation driver used to perform the check.
+ *
+ */
+function checkNonAnimatableInTimelines(timelines, triggerName, driver) {
+    if (!driver.validateAnimatableStyleProperty) {
+        return;
+    }
+    const allowedNonAnimatableProps = new Set([
+        // 'easing' is a utility/synthetic prop we use to represent
+        // easing functions, it represents a property of the animation
+        // which is not animatable but different values can be used
+        // in different steps
+        'easing',
+    ]);
+    const invalidNonAnimatableProps = new Set();
+    timelines.forEach(({ keyframes }) => {
+        const nonAnimatablePropsInitialValues = new Map();
+        keyframes.forEach((keyframe) => {
+            const entriesToCheck = Array.from(keyframe.entries()).filter(([prop]) => !allowedNonAnimatableProps.has(prop));
+            for (const [prop, value] of entriesToCheck) {
+                if (!driver.validateAnimatableStyleProperty(prop)) {
+                    if (nonAnimatablePropsInitialValues.has(prop) && !invalidNonAnimatableProps.has(prop)) {
+                        const propInitialValue = nonAnimatablePropsInitialValues.get(prop);
+                        if (propInitialValue !== value) {
+                            invalidNonAnimatableProps.add(prop);
+                        }
+                    }
+                    else {
+                        nonAnimatablePropsInitialValues.set(prop, value);
+                    }
+                }
+            }
+        });
+    });
+    if (invalidNonAnimatableProps.size > 0) {
+        console.warn(`Warning: The animation trigger "${triggerName}" is attempting to animate the following` +
+            ' not animatable properties: ' +
+            Array.from(invalidNonAnimatableProps).join(', ') +
+            '\n' +
+            '(to check the list of all animatable properties visit https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_animated_properties)');
+    }
+}
+function oneOrMoreTransitionsMatch(matchFns, currentState, nextState, element, params) {
+    return matchFns.some((fn) => fn(currentState, nextState, element, params));
+}
+function applyParamDefaults(userParams, defaults) {
+    const result = { ...defaults };
+    Object.entries(userParams).forEach(([key, value]) => {
+        if (value != null) {
+            result[key] = value;
+        }
+    });
+    return result;
+}
+class AnimationStateStyles {
+    styles;
+    defaultParams;
+    normalizer;
+    constructor(styles, defaultParams, normalizer) {
+        this.styles = styles;
+        this.defaultParams = defaultParams;
+        this.normalizer = normalizer;
+    }
+    buildStyles(params, errors) {
+        const finalStyles = new Map();
+        const combinedParams = applyParamDefaults(params, this.defaultParams);
+        this.styles.styles.forEach((value) => {
+            if (typeof value !== 'string') {
+                value.forEach((val, prop) => {
+                    if (val) {
+                        val = interpolateParams(val, combinedParams, errors);
+                    }
+                    const normalizedProp = this.normalizer.normalizePropertyName(prop, errors);
+                    val = this.normalizer.normalizeStyleValue(prop, normalizedProp, val, errors);
+                    finalStyles.set(prop, val);
+                });
+            }
+        });
+        return finalStyles;
+    }
+}
+
+function buildTrigger(name, ast, normalizer) {
+    return new AnimationTrigger(name, ast, normalizer);
+}
+class AnimationTrigger {
+    name;
+    ast;
+    _normalizer;
+    transitionFactories = [];
+    fallbackTransition;
+    states = new Map();
+    constructor(name, ast, _normalizer) {
+        this.name = name;
+        this.ast = ast;
+        this._normalizer = _normalizer;
+        ast.states.forEach((ast) => {
+            const defaultParams = (ast.options && ast.options.params) || {};
+            this.states.set(ast.name, new AnimationStateStyles(ast.style, defaultParams, _normalizer));
+        });
+        balanceProperties(this.states, 'true', '1');
+        balanceProperties(this.states, 'false', '0');
+        ast.transitions.forEach((ast) => {
+            this.transitionFactories.push(new AnimationTransitionFactory(name, ast, this.states));
+        });
+        this.fallbackTransition = createFallbackTransition(name, this.states);
+    }
+    get containsQueries() {
+        return this.ast.queryCount > 0;
+    }
+    matchTransition(currentState, nextState, element, params) {
+        const entry = this.transitionFactories.find((f) => f.match(currentState, nextState, element, params));
+        return entry || null;
+    }
+    matchStyles(currentState, params, errors) {
+        return this.fallbackTransition.buildStyles(currentState, params, errors);
+    }
+}
+function createFallbackTransition(triggerName, states, normalizer) {
+    const matchers = [(fromState, toState) => true];
+    const animation = { type: AnimationMetadataType.Sequence, steps: [], options: null };
+    const transition = {
+        type: AnimationMetadataType.Transition,
+        animation,
+        matchers,
+        options: null,
+        queryCount: 0,
+        depCount: 0,
+    };
+    return new AnimationTransitionFactory(triggerName, transition, states);
+}
+function balanceProperties(stateMap, key1, key2) {
+    if (stateMap.has(key1)) {
+        if (!stateMap.has(key2)) {
+            stateMap.set(key2, stateMap.get(key1));
+        }
+    }
+    else if (stateMap.has(key2)) {
+        stateMap.set(key1, stateMap.get(key2));
+    }
+}
+
+const EMPTY_INSTRUCTION_MAP = /* @__PURE__ */ new ElementInstructionMap();
+class TimelineAnimationEngine {
+    bodyNode;
+    _driver;
+    _normalizer;
+    _animations = new Map();
+    _playersById = new Map();
+    players = [];
+    constructor(bodyNode, _driver, _normalizer) {
+        this.bodyNode = bodyNode;
+        this._driver = _driver;
+        this._normalizer = _normalizer;
+    }
+    register(id, metadata) {
+        const errors = [];
+        const warnings = [];
+        const ast = buildAnimationAst(this._driver, metadata, errors, warnings);
+        if (errors.length) {
+            throw registerFailed(errors);
+        }
+        else {
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                if (warnings.length) {
+                    warnRegister(warnings);
+                }
+            }
+            this._animations.set(id, ast);
+        }
+    }
+    _buildPlayer(i, preStyles, postStyles) {
+        const element = i.element;
+        const keyframes = normalizeKeyframes(this._normalizer, i.keyframes, preStyles, postStyles);
+        return this._driver.animate(element, keyframes, i.duration, i.delay, i.easing, [], true);
+    }
+    create(id, element, options = {}) {
+        const errors = [];
+        const ast = this._animations.get(id);
+        let instructions;
+        const autoStylesMap = new Map();
+        if (ast) {
+            instructions = buildAnimationTimelines(this._driver, element, ast, ENTER_CLASSNAME, LEAVE_CLASSNAME, new Map(), new Map(), options, EMPTY_INSTRUCTION_MAP, errors);
+            instructions.forEach((inst) => {
+                const styles = getOrSetDefaultValue(autoStylesMap, inst.element, new Map());
+                inst.postStyleProps.forEach((prop) => styles.set(prop, null));
+            });
+        }
+        else {
+            errors.push(missingOrDestroyedAnimation());
+            instructions = [];
+        }
+        if (errors.length) {
+            throw createAnimationFailed(errors);
+        }
+        autoStylesMap.forEach((styles, element) => {
+            styles.forEach((_, prop) => {
+                styles.set(prop, this._driver.computeStyle(element, prop, AUTO_STYLE));
+            });
+        });
+        const players = instructions.map((i) => {
+            const styles = autoStylesMap.get(i.element);
+            return this._buildPlayer(i, new Map(), styles);
+        });
+        const player = optimizeGroupPlayer(players);
+        this._playersById.set(id, player);
+        player.onDestroy(() => this.destroy(id));
+        this.players.push(player);
+        return player;
+    }
+    destroy(id) {
+        const player = this._getPlayer(id);
+        player.destroy();
+        this._playersById.delete(id);
+        const index = this.players.indexOf(player);
+        if (index >= 0) {
+            this.players.splice(index, 1);
+        }
+    }
+    _getPlayer(id) {
+        const player = this._playersById.get(id);
+        if (!player) {
+            throw missingPlayer(id);
+        }
+        return player;
+    }
+    listen(id, element, eventName, callback) {
+        // triggerName, fromState, toState are all ignored for timeline animations
+        const baseEvent = makeAnimationEvent(element, '', '', '');
+        listenOnPlayer(this._getPlayer(id), eventName, baseEvent, callback);
+        return () => { };
+    }
+    command(id, element, command, args) {
+        if (command == 'register') {
+            this.register(id, args[0]);
+            return;
+        }
+        if (command == 'create') {
+            const options = (args[0] || {});
+            this.create(id, element, options);
+            return;
+        }
+        const player = this._getPlayer(id);
+        switch (command) {
+            case 'play':
+                player.play();
+                break;
+            case 'pause':
+                player.pause();
+                break;
+            case 'reset':
+                player.reset();
+                break;
+            case 'restart':
+                player.restart();
+                break;
+            case 'finish':
+                player.finish();
+                break;
+            case 'init':
+                player.init();
+                break;
+            case 'setPosition':
+                player.setPosition(parseFloat(args[0]));
+                break;
+            case 'destroy':
+                this.destroy(id);
+                break;
+        }
+    }
+}
+
+const QUEUED_CLASSNAME = 'ng-animate-queued';
+const QUEUED_SELECTOR = '.ng-animate-queued';
+const DISABLED_CLASSNAME = 'ng-animate-disabled';
+const DISABLED_SELECTOR = '.ng-animate-disabled';
+const STAR_CLASSNAME = 'ng-star-inserted';
+const STAR_SELECTOR = '.ng-star-inserted';
+const EMPTY_PLAYER_ARRAY = [];
+const NULL_REMOVAL_STATE = {
+    namespaceId: '',
+    setForRemoval: false,
+    setForMove: false,
+    hasAnimation: false,
+    removedBeforeQueried: false,
+};
+const NULL_REMOVED_QUERIED_STATE = {
+    namespaceId: '',
+    setForMove: false,
+    setForRemoval: false,
+    hasAnimation: false,
+    removedBeforeQueried: true,
+};
+const REMOVAL_FLAG = '__ng_removed';
+class StateValue {
+    namespaceId;
+    value;
+    options;
+    get params() {
+        return this.options.params;
+    }
+    constructor(input, namespaceId = '') {
+        this.namespaceId = namespaceId;
+        const isObj = input && input.hasOwnProperty('value');
+        const value = isObj ? input['value'] : input;
+        this.value = normalizeTriggerValue(value);
+        if (isObj) {
+            // we drop the value property from options.
+            const { value, ...options } = input;
+            this.options = options;
+        }
+        else {
+            this.options = {};
+        }
+        if (!this.options.params) {
+            this.options.params = {};
+        }
+    }
+    absorbOptions(options) {
+        const newParams = options.params;
+        if (newParams) {
+            const oldParams = this.options.params;
+            Object.keys(newParams).forEach((prop) => {
+                if (oldParams[prop] == null) {
+                    oldParams[prop] = newParams[prop];
+                }
+            });
+        }
+    }
+}
+const VOID_VALUE = 'void';
+const DEFAULT_STATE_VALUE = /* @__PURE__ */ new StateValue(VOID_VALUE);
+class AnimationTransitionNamespace {
+    id;
+    hostElement;
+    _engine;
+    players = [];
+    _triggers = new Map();
+    _queue = [];
+    _elementListeners = new Map();
+    _hostClassName;
+    constructor(id, hostElement, _engine) {
+        this.id = id;
+        this.hostElement = hostElement;
+        this._engine = _engine;
+        this._hostClassName = 'ng-tns-' + id;
+        addClass(hostElement, this._hostClassName);
+    }
+    listen(element, name, phase, callback) {
+        if (!this._triggers.has(name)) {
+            throw missingTrigger(phase, name);
+        }
+        if (phase == null || phase.length == 0) {
+            throw missingEvent(name);
+        }
+        if (!isTriggerEventValid(phase)) {
+            throw unsupportedTriggerEvent(phase, name);
+        }
+        const listeners = getOrSetDefaultValue(this._elementListeners, element, []);
+        const data = { name, phase, callback };
+        listeners.push(data);
+        const triggersWithStates = getOrSetDefaultValue(this._engine.statesByElement, element, new Map());
+        if (!triggersWithStates.has(name)) {
+            addClass(element, NG_TRIGGER_CLASSNAME);
+            addClass(element, NG_TRIGGER_CLASSNAME + '-' + name);
+            triggersWithStates.set(name, DEFAULT_STATE_VALUE);
+        }
+        return () => {
+            // the event listener is removed AFTER the flush has occurred such
+            // that leave animations callbacks can fire (otherwise if the node
+            // is removed in between then the listeners would be deregistered)
+            this._engine.afterFlush(() => {
+                const index = listeners.indexOf(data);
+                if (index >= 0) {
+                    listeners.splice(index, 1);
+                }
+                if (!this._triggers.has(name)) {
+                    triggersWithStates.delete(name);
+                }
+            });
+        };
+    }
+    register(name, ast) {
+        if (this._triggers.has(name)) {
+            // throw
+            return false;
+        }
+        else {
+            this._triggers.set(name, ast);
+            return true;
+        }
+    }
+    _getTrigger(name) {
+        const trigger = this._triggers.get(name);
+        if (!trigger) {
+            throw unregisteredTrigger(name);
+        }
+        return trigger;
+    }
+    trigger(element, triggerName, value, defaultToFallback = true) {
+        const trigger = this._getTrigger(triggerName);
+        const player = new TransitionAnimationPlayer(this.id, triggerName, element);
+        let triggersWithStates = this._engine.statesByElement.get(element);
+        if (!triggersWithStates) {
+            addClass(element, NG_TRIGGER_CLASSNAME);
+            addClass(element, NG_TRIGGER_CLASSNAME + '-' + triggerName);
+            this._engine.statesByElement.set(element, (triggersWithStates = new Map()));
+        }
+        let fromState = triggersWithStates.get(triggerName);
+        const toState = new StateValue(value, this.id);
+        const isObj = value && value.hasOwnProperty('value');
+        if (!isObj && fromState) {
+            toState.absorbOptions(fromState.options);
+        }
+        triggersWithStates.set(triggerName, toState);
+        if (!fromState) {
+            fromState = DEFAULT_STATE_VALUE;
+        }
+        const isRemoval = toState.value === VOID_VALUE;
+        // normally this isn't reached by here, however, if an object expression
+        // is passed in then it may be a new object each time. Comparing the value
+        // is important since that will stay the same despite there being a new object.
+        // The removal arc here is special cased because the same element is triggered
+        // twice in the event that it contains animations on the outer/inner portions
+        // of the host container
+        if (!isRemoval && fromState.value === toState.value) {
+            // this means that despite the value not changing, some inner params
+            // have changed which means that the animation final styles need to be applied
+            if (!objEquals(fromState.params, toState.params)) {
+                const errors = [];
+                const fromStyles = trigger.matchStyles(fromState.value, fromState.params, errors);
+                const toStyles = trigger.matchStyles(toState.value, toState.params, errors);
+                if (errors.length) {
+                    this._engine.reportError(errors);
+                }
+                else {
+                    this._engine.afterFlush(() => {
+                        eraseStyles(element, fromStyles);
+                        setStyles(element, toStyles);
+                    });
+                }
+            }
+            return;
+        }
+        const playersOnElement = getOrSetDefaultValue(this._engine.playersByElement, element, []);
+        playersOnElement.forEach((player) => {
+            // only remove the player if it is queued on the EXACT same trigger/namespace
+            // we only also deal with queued players here because if the animation has
+            // started then we want to keep the player alive until the flush happens
+            // (which is where the previousPlayers are passed into the new player)
+            if (player.namespaceId == this.id && player.triggerName == triggerName && player.queued) {
+                player.destroy();
+            }
+        });
+        let transition = trigger.matchTransition(fromState.value, toState.value, element, toState.params);
+        let isFallbackTransition = false;
+        if (!transition) {
+            if (!defaultToFallback)
+                return;
+            transition = trigger.fallbackTransition;
+            isFallbackTransition = true;
+        }
+        this._engine.totalQueuedPlayers++;
+        this._queue.push({
+            element,
+            triggerName,
+            transition,
+            fromState,
+            toState,
+            player,
+            isFallbackTransition,
+        });
+        if (!isFallbackTransition) {
+            addClass(element, QUEUED_CLASSNAME);
+            player.onStart(() => {
+                removeClass(element, QUEUED_CLASSNAME);
+            });
+        }
+        player.onDone(() => {
+            let index = this.players.indexOf(player);
+            if (index >= 0) {
+                this.players.splice(index, 1);
+            }
+            const players = this._engine.playersByElement.get(element);
+            if (players) {
+                let index = players.indexOf(player);
+                if (index >= 0) {
+                    players.splice(index, 1);
+                }
+            }
+        });
+        this.players.push(player);
+        playersOnElement.push(player);
+        return player;
+    }
+    deregister(name) {
+        this._triggers.delete(name);
+        this._engine.statesByElement.forEach((stateMap) => stateMap.delete(name));
+        this._elementListeners.forEach((listeners, element) => {
+            this._elementListeners.set(element, listeners.filter((entry) => {
+                return entry.name != name;
+            }));
+        });
+    }
+    clearElementCache(element) {
+        this._engine.statesByElement.delete(element);
+        this._elementListeners.delete(element);
+        const elementPlayers = this._engine.playersByElement.get(element);
+        if (elementPlayers) {
+            elementPlayers.forEach((player) => player.destroy());
+            this._engine.playersByElement.delete(element);
+        }
+    }
+    _signalRemovalForInnerTriggers(rootElement, context) {
+        const elements = this._engine.driver.query(rootElement, NG_TRIGGER_SELECTOR, true);
+        // emulate a leave animation for all inner nodes within this node.
+        // If there are no animations found for any of the nodes then clear the cache
+        // for the element.
+        elements.forEach((elm) => {
+            // this means that an inner remove() operation has already kicked off
+            // the animation on this element...
+            if (elm[REMOVAL_FLAG])
+                return;
+            const namespaces = this._engine.fetchNamespacesByElement(elm);
+            if (namespaces.size) {
+                namespaces.forEach((ns) => ns.triggerLeaveAnimation(elm, context, false, true));
+            }
+            else {
+                this.clearElementCache(elm);
+            }
+        });
+        // If the child elements were removed along with the parent, their animations might not
+        // have completed. Clear all the elements from the cache so we don't end up with a memory leak.
+        this._engine.afterFlushAnimationsDone(() => elements.forEach((elm) => this.clearElementCache(elm)));
+    }
+    triggerLeaveAnimation(element, context, destroyAfterComplete, defaultToFallback) {
+        const triggerStates = this._engine.statesByElement.get(element);
+        const previousTriggersValues = new Map();
+        if (triggerStates) {
+            const players = [];
+            triggerStates.forEach((state, triggerName) => {
+                previousTriggersValues.set(triggerName, state.value);
+                // this check is here in the event that an element is removed
+                // twice (both on the host level and the component level)
+                if (this._triggers.has(triggerName)) {
+                    const player = this.trigger(element, triggerName, VOID_VALUE, defaultToFallback);
+                    if (player) {
+                        players.push(player);
+                    }
+                }
+            });
+            if (players.length) {
+                this._engine.markElementAsRemoved(this.id, element, true, context, previousTriggersValues);
+                if (destroyAfterComplete) {
+                    optimizeGroupPlayer(players).onDone(() => this._engine.processLeaveNode(element));
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    prepareLeaveAnimationListeners(element) {
+        const listeners = this._elementListeners.get(element);
+        const elementStates = this._engine.statesByElement.get(element);
+        // if this statement fails then it means that the element was picked up
+        // by an earlier flush (or there are no listeners at all to track the leave).
+        if (listeners && elementStates) {
+            const visitedTriggers = new Set();
+            listeners.forEach((listener) => {
+                const triggerName = listener.name;
+                if (visitedTriggers.has(triggerName))
+                    return;
+                visitedTriggers.add(triggerName);
+                const trigger = this._triggers.get(triggerName);
+                const transition = trigger.fallbackTransition;
+                const fromState = elementStates.get(triggerName) || DEFAULT_STATE_VALUE;
+                const toState = new StateValue(VOID_VALUE);
+                const player = new TransitionAnimationPlayer(this.id, triggerName, element);
+                this._engine.totalQueuedPlayers++;
+                this._queue.push({
+                    element,
+                    triggerName,
+                    transition,
+                    fromState,
+                    toState,
+                    player,
+                    isFallbackTransition: true,
+                });
+            });
+        }
+    }
+    removeNode(element, context) {
+        const engine = this._engine;
+        if (element.childElementCount) {
+            this._signalRemovalForInnerTriggers(element, context);
+        }
+        // this means that a * => VOID animation was detected and kicked off
+        if (this.triggerLeaveAnimation(element, context, true))
+            return;
+        // find the player that is animating and make sure that the
+        // removal is delayed until that player has completed
+        let containsPotentialParentTransition = false;
+        if (engine.totalAnimations) {
+            const currentPlayers = engine.players.length
+                ? engine.playersByQueriedElement.get(element)
+                : [];
+            // when this `if statement` does not continue forward it means that
+            // a previous animation query has selected the current element and
+            // is animating it. In this situation want to continue forwards and
+            // allow the element to be queued up for animation later.
+            if (currentPlayers && currentPlayers.length) {
+                containsPotentialParentTransition = true;
+            }
+            else {
+                let parent = element;
+                while ((parent = parent.parentNode)) {
+                    const triggers = engine.statesByElement.get(parent);
+                    if (triggers) {
+                        containsPotentialParentTransition = true;
+                        break;
+                    }
+                }
+            }
+        }
+        // at this stage we know that the element will either get removed
+        // during flush or will be picked up by a parent query. Either way
+        // we need to fire the listeners for this element when it DOES get
+        // removed (once the query parent animation is done or after flush)
+        this.prepareLeaveAnimationListeners(element);
+        // whether or not a parent has an animation we need to delay the deferral of the leave
+        // operation until we have more information (which we do after flush() has been called)
+        if (containsPotentialParentTransition) {
+            engine.markElementAsRemoved(this.id, element, false, context);
+        }
+        else {
+            const removalFlag = element[REMOVAL_FLAG];
+            if (!removalFlag || removalFlag === NULL_REMOVAL_STATE) {
+                // we do this after the flush has occurred such
+                // that the callbacks can be fired
+                engine.afterFlush(() => this.clearElementCache(element));
+                engine.destroyInnerAnimations(element);
+                engine._onRemovalComplete(element, context);
+            }
+        }
+    }
+    insertNode(element, parent) {
+        addClass(element, this._hostClassName);
+    }
+    drainQueuedTransitions(microtaskId) {
+        const instructions = [];
+        this._queue.forEach((entry) => {
+            const player = entry.player;
+            if (player.destroyed)
+                return;
+            const element = entry.element;
+            const listeners = this._elementListeners.get(element);
+            if (listeners) {
+                listeners.forEach((listener) => {
+                    if (listener.name == entry.triggerName) {
+                        const baseEvent = makeAnimationEvent(element, entry.triggerName, entry.fromState.value, entry.toState.value);
+                        baseEvent['_data'] = microtaskId;
+                        listenOnPlayer(entry.player, listener.phase, baseEvent, listener.callback);
+                    }
+                });
+            }
+            if (player.markedForDestroy) {
+                this._engine.afterFlush(() => {
+                    // now we can destroy the element properly since the event listeners have
+                    // been bound to the player
+                    player.destroy();
+                });
+            }
+            else {
+                instructions.push(entry);
+            }
+        });
+        this._queue = [];
+        return instructions.sort((a, b) => {
+            // if depCount == 0 them move to front
+            // otherwise if a contains b then move back
+            const d0 = a.transition.ast.depCount;
+            const d1 = b.transition.ast.depCount;
+            if (d0 == 0 || d1 == 0) {
+                return d0 - d1;
+            }
+            return this._engine.driver.containsElement(a.element, b.element) ? 1 : -1;
+        });
+    }
+    destroy(context) {
+        this.players.forEach((p) => p.destroy());
+        this._signalRemovalForInnerTriggers(this.hostElement, context);
+    }
+}
+class TransitionAnimationEngine {
+    bodyNode;
+    driver;
+    _normalizer;
+    players = [];
+    newHostElements = new Map();
+    playersByElement = new Map();
+    playersByQueriedElement = new Map();
+    statesByElement = new Map();
+    disabledNodes = new Set();
+    totalAnimations = 0;
+    totalQueuedPlayers = 0;
+    _namespaceLookup = {};
+    _namespaceList = [];
+    _flushFns = [];
+    _whenQuietFns = [];
+    namespacesByHostElement = new Map();
+    collectedEnterElements = [];
+    collectedLeaveElements = [];
+    // this method is designed to be overridden by the code that uses this engine
+    onRemovalComplete = (element, context) => { };
+    /** @internal */
+    _onRemovalComplete(element, context) {
+        this.onRemovalComplete(element, context);
+    }
+    constructor(bodyNode, driver, _normalizer) {
+        this.bodyNode = bodyNode;
+        this.driver = driver;
+        this._normalizer = _normalizer;
+    }
+    get queuedPlayers() {
+        const players = [];
+        this._namespaceList.forEach((ns) => {
+            ns.players.forEach((player) => {
+                if (player.queued) {
+                    players.push(player);
+                }
+            });
+        });
+        return players;
+    }
+    createNamespace(namespaceId, hostElement) {
+        const ns = new AnimationTransitionNamespace(namespaceId, hostElement, this);
+        if (this.bodyNode && this.driver.containsElement(this.bodyNode, hostElement)) {
+            this._balanceNamespaceList(ns, hostElement);
+        }
+        else {
+            // defer this later until flush during when the host element has
+            // been inserted so that we know exactly where to place it in
+            // the namespace list
+            this.newHostElements.set(hostElement, ns);
+            // given that this host element is a part of the animation code, it
+            // may or may not be inserted by a parent node that is of an
+            // animation renderer type. If this happens then we can still have
+            // access to this item when we query for :enter nodes. If the parent
+            // is a renderer then the set data-structure will normalize the entry
+            this.collectEnterElement(hostElement);
+        }
+        return (this._namespaceLookup[namespaceId] = ns);
+    }
+    _balanceNamespaceList(ns, hostElement) {
+        const namespaceList = this._namespaceList;
+        const namespacesByHostElement = this.namespacesByHostElement;
+        const limit = namespaceList.length - 1;
+        if (limit >= 0) {
+            let found = false;
+            // Find the closest ancestor with an existing namespace so we can then insert `ns` after it,
+            // establishing a top-down ordering of namespaces in `this._namespaceList`.
+            let ancestor = this.driver.getParentElement(hostElement);
+            while (ancestor) {
+                const ancestorNs = namespacesByHostElement.get(ancestor);
+                if (ancestorNs) {
+                    // An animation namespace has been registered for this ancestor, so we insert `ns`
+                    // right after it to establish top-down ordering of animation namespaces.
+                    const index = namespaceList.indexOf(ancestorNs);
+                    namespaceList.splice(index + 1, 0, ns);
+                    found = true;
+                    break;
+                }
+                ancestor = this.driver.getParentElement(ancestor);
+            }
+            if (!found) {
+                // No namespace exists that is an ancestor of `ns`, so `ns` is inserted at the front to
+                // ensure that any existing descendants are ordered after `ns`, retaining the desired
+                // top-down ordering.
+                namespaceList.unshift(ns);
+            }
+        }
+        else {
+            namespaceList.push(ns);
+        }
+        namespacesByHostElement.set(hostElement, ns);
+        return ns;
+    }
+    register(namespaceId, hostElement) {
+        let ns = this._namespaceLookup[namespaceId];
+        if (!ns) {
+            ns = this.createNamespace(namespaceId, hostElement);
+        }
+        return ns;
+    }
+    registerTrigger(namespaceId, name, trigger) {
+        let ns = this._namespaceLookup[namespaceId];
+        if (ns && ns.register(name, trigger)) {
+            this.totalAnimations++;
+        }
+    }
+    destroy(namespaceId, context) {
+        if (!namespaceId)
+            return;
+        this.afterFlush(() => { });
+        this.afterFlushAnimationsDone(() => {
+            const ns = this._fetchNamespace(namespaceId);
+            this.namespacesByHostElement.delete(ns.hostElement);
+            const index = this._namespaceList.indexOf(ns);
+            if (index >= 0) {
+                this._namespaceList.splice(index, 1);
+            }
+            ns.destroy(context);
+            delete this._namespaceLookup[namespaceId];
+        });
+    }
+    _fetchNamespace(id) {
+        return this._namespaceLookup[id];
+    }
+    fetchNamespacesByElement(element) {
+        // normally there should only be one namespace per element, however
+        // if @triggers are placed on both the component element and then
+        // its host element (within the component code) then there will be
+        // two namespaces returned. We use a set here to simply deduplicate
+        // the namespaces in case (for the reason described above) there are multiple triggers
+        const namespaces = new Set();
+        const elementStates = this.statesByElement.get(element);
+        if (elementStates) {
+            for (let stateValue of elementStates.values()) {
+                if (stateValue.namespaceId) {
+                    const ns = this._fetchNamespace(stateValue.namespaceId);
+                    if (ns) {
+                        namespaces.add(ns);
+                    }
+                }
+            }
+        }
+        return namespaces;
+    }
+    trigger(namespaceId, element, name, value) {
+        if (isElementNode(element)) {
+            const ns = this._fetchNamespace(namespaceId);
+            if (ns) {
+                ns.trigger(element, name, value);
+                return true;
+            }
+        }
+        return false;
+    }
+    insertNode(namespaceId, element, parent, insertBefore) {
+        if (!isElementNode(element))
+            return;
+        // special case for when an element is removed and reinserted (move operation)
+        // when this occurs we do not want to use the element for deletion later
+        const details = element[REMOVAL_FLAG];
+        if (details && details.setForRemoval) {
+            details.setForRemoval = false;
+            details.setForMove = true;
+            const index = this.collectedLeaveElements.indexOf(element);
+            if (index >= 0) {
+                this.collectedLeaveElements.splice(index, 1);
+            }
+        }
+        // in the event that the namespaceId is blank then the caller
+        // code does not contain any animation code in it, but it is
+        // just being called so that the node is marked as being inserted
+        if (namespaceId) {
+            const ns = this._fetchNamespace(namespaceId);
+            // This if-statement is a workaround for router issue #21947.
+            // The router sometimes hits a race condition where while a route
+            // is being instantiated a new navigation arrives, triggering leave
+            // animation of DOM that has not been fully initialized, until this
+            // is resolved, we need to handle the scenario when DOM is not in a
+            // consistent state during the animation.
+            if (ns) {
+                ns.insertNode(element, parent);
+            }
+        }
+        // only *directives and host elements are inserted before
+        if (insertBefore) {
+            this.collectEnterElement(element);
+        }
+    }
+    collectEnterElement(element) {
+        this.collectedEnterElements.push(element);
+    }
+    markElementAsDisabled(element, value) {
+        if (value) {
+            if (!this.disabledNodes.has(element)) {
+                this.disabledNodes.add(element);
+                addClass(element, DISABLED_CLASSNAME);
+            }
+        }
+        else if (this.disabledNodes.has(element)) {
+            this.disabledNodes.delete(element);
+            removeClass(element, DISABLED_CLASSNAME);
+        }
+    }
+    removeNode(namespaceId, element, context) {
+        if (isElementNode(element)) {
+            const ns = namespaceId ? this._fetchNamespace(namespaceId) : null;
+            if (ns) {
+                ns.removeNode(element, context);
+            }
+            else {
+                this.markElementAsRemoved(namespaceId, element, false, context);
+            }
+            const hostNS = this.namespacesByHostElement.get(element);
+            if (hostNS && hostNS.id !== namespaceId) {
+                hostNS.removeNode(element, context);
+            }
+        }
+        else {
+            this._onRemovalComplete(element, context);
+        }
+    }
+    markElementAsRemoved(namespaceId, element, hasAnimation, context, previousTriggersValues) {
+        this.collectedLeaveElements.push(element);
+        element[REMOVAL_FLAG] = {
+            namespaceId,
+            setForRemoval: context,
+            hasAnimation,
+            removedBeforeQueried: false,
+            previousTriggersValues,
+        };
+    }
+    listen(namespaceId, element, name, phase, callback) {
+        if (isElementNode(element)) {
+            return this._fetchNamespace(namespaceId).listen(element, name, phase, callback);
+        }
+        return () => { };
+    }
+    _buildInstruction(entry, subTimelines, enterClassName, leaveClassName, skipBuildAst) {
+        return entry.transition.build(this.driver, entry.element, entry.fromState.value, entry.toState.value, enterClassName, leaveClassName, entry.fromState.options, entry.toState.options, subTimelines, skipBuildAst);
+    }
+    destroyInnerAnimations(containerElement) {
+        let elements = this.driver.query(containerElement, NG_TRIGGER_SELECTOR, true);
+        elements.forEach((element) => this.destroyActiveAnimationsForElement(element));
+        if (this.playersByQueriedElement.size == 0)
+            return;
+        elements = this.driver.query(containerElement, NG_ANIMATING_SELECTOR, true);
+        elements.forEach((element) => this.finishActiveQueriedAnimationOnElement(element));
+    }
+    destroyActiveAnimationsForElement(element) {
+        const players = this.playersByElement.get(element);
+        if (players) {
+            players.forEach((player) => {
+                // special case for when an element is set for destruction, but hasn't started.
+                // in this situation we want to delay the destruction until the flush occurs
+                // so that any event listeners attached to the player are triggered.
+                if (player.queued) {
+                    player.markedForDestroy = true;
+                }
+                else {
+                    player.destroy();
+                }
+            });
+        }
+    }
+    finishActiveQueriedAnimationOnElement(element) {
+        const players = this.playersByQueriedElement.get(element);
+        if (players) {
+            players.forEach((player) => player.finish());
+        }
+    }
+    whenRenderingDone() {
+        return new Promise((resolve) => {
+            if (this.players.length) {
+                return optimizeGroupPlayer(this.players).onDone(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    processLeaveNode(element) {
+        const details = element[REMOVAL_FLAG];
+        if (details && details.setForRemoval) {
+            // this will prevent it from removing it twice
+            element[REMOVAL_FLAG] = NULL_REMOVAL_STATE;
+            if (details.namespaceId) {
+                this.destroyInnerAnimations(element);
+                const ns = this._fetchNamespace(details.namespaceId);
+                if (ns) {
+                    ns.clearElementCache(element);
+                }
+            }
+            this._onRemovalComplete(element, details.setForRemoval);
+        }
+        if (element.classList?.contains(DISABLED_CLASSNAME)) {
+            this.markElementAsDisabled(element, false);
+        }
+        this.driver.query(element, DISABLED_SELECTOR, true).forEach((node) => {
+            this.markElementAsDisabled(node, false);
+        });
+    }
+    flush(microtaskId = -1) {
+        let players = [];
+        if (this.newHostElements.size) {
+            this.newHostElements.forEach((ns, element) => this._balanceNamespaceList(ns, element));
+            this.newHostElements.clear();
+        }
+        if (this.totalAnimations && this.collectedEnterElements.length) {
+            for (let i = 0; i < this.collectedEnterElements.length; i++) {
+                const elm = this.collectedEnterElements[i];
+                addClass(elm, STAR_CLASSNAME);
+            }
+        }
+        if (this._namespaceList.length &&
+            (this.totalQueuedPlayers || this.collectedLeaveElements.length)) {
+            const cleanupFns = [];
+            try {
+                players = this._flushAnimations(cleanupFns, microtaskId);
+            }
+            finally {
+                for (let i = 0; i < cleanupFns.length; i++) {
+                    cleanupFns[i]();
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < this.collectedLeaveElements.length; i++) {
+                const element = this.collectedLeaveElements[i];
+                this.processLeaveNode(element);
+            }
+        }
+        this.totalQueuedPlayers = 0;
+        this.collectedEnterElements.length = 0;
+        this.collectedLeaveElements.length = 0;
+        this._flushFns.forEach((fn) => fn());
+        this._flushFns = [];
+        if (this._whenQuietFns.length) {
+            // we move these over to a variable so that
+            // if any new callbacks are registered in another
+            // flush they do not populate the existing set
+            const quietFns = this._whenQuietFns;
+            this._whenQuietFns = [];
+            if (players.length) {
+                optimizeGroupPlayer(players).onDone(() => {
+                    quietFns.forEach((fn) => fn());
+                });
+            }
+            else {
+                quietFns.forEach((fn) => fn());
+            }
+        }
+    }
+    reportError(errors) {
+        throw triggerTransitionsFailed(errors);
+    }
+    _flushAnimations(cleanupFns, microtaskId) {
+        const subTimelines = new ElementInstructionMap();
+        const skippedPlayers = [];
+        const skippedPlayersMap = new Map();
+        const queuedInstructions = [];
+        const queriedElements = new Map();
+        const allPreStyleElements = new Map();
+        const allPostStyleElements = new Map();
+        const disabledElementsSet = new Set();
+        this.disabledNodes.forEach((node) => {
+            disabledElementsSet.add(node);
+            const nodesThatAreDisabled = this.driver.query(node, QUEUED_SELECTOR, true);
+            for (let i = 0; i < nodesThatAreDisabled.length; i++) {
+                disabledElementsSet.add(nodesThatAreDisabled[i]);
+            }
+        });
+        const bodyNode = this.bodyNode;
+        const allTriggerElements = Array.from(this.statesByElement.keys());
+        const enterNodeMap = buildRootMap(allTriggerElements, this.collectedEnterElements);
+        // this must occur before the instructions are built below such that
+        // the :enter queries match the elements (since the timeline queries
+        // are fired during instruction building).
+        const enterNodeMapIds = new Map();
+        let i = 0;
+        enterNodeMap.forEach((nodes, root) => {
+            const className = ENTER_CLASSNAME + i++;
+            enterNodeMapIds.set(root, className);
+            nodes.forEach((node) => addClass(node, className));
+        });
+        const allLeaveNodes = [];
+        const mergedLeaveNodes = new Set();
+        const leaveNodesWithoutAnimations = new Set();
+        for (let i = 0; i < this.collectedLeaveElements.length; i++) {
+            const element = this.collectedLeaveElements[i];
+            const details = element[REMOVAL_FLAG];
+            if (details && details.setForRemoval) {
+                allLeaveNodes.push(element);
+                mergedLeaveNodes.add(element);
+                if (details.hasAnimation) {
+                    this.driver
+                        .query(element, STAR_SELECTOR, true)
+                        .forEach((elm) => mergedLeaveNodes.add(elm));
+                }
+                else {
+                    leaveNodesWithoutAnimations.add(element);
+                }
+            }
+        }
+        const leaveNodeMapIds = new Map();
+        const leaveNodeMap = buildRootMap(allTriggerElements, Array.from(mergedLeaveNodes));
+        leaveNodeMap.forEach((nodes, root) => {
+            const className = LEAVE_CLASSNAME + i++;
+            leaveNodeMapIds.set(root, className);
+            nodes.forEach((node) => addClass(node, className));
+        });
+        cleanupFns.push(() => {
+            enterNodeMap.forEach((nodes, root) => {
+                const className = enterNodeMapIds.get(root);
+                nodes.forEach((node) => removeClass(node, className));
+            });
+            leaveNodeMap.forEach((nodes, root) => {
+                const className = leaveNodeMapIds.get(root);
+                nodes.forEach((node) => removeClass(node, className));
+            });
+            allLeaveNodes.forEach((element) => {
+                this.processLeaveNode(element);
+            });
+        });
+        const allPlayers = [];
+        const erroneousTransitions = [];
+        for (let i = this._namespaceList.length - 1; i >= 0; i--) {
+            const ns = this._namespaceList[i];
+            ns.drainQueuedTransitions(microtaskId).forEach((entry) => {
+                const player = entry.player;
+                const element = entry.element;
+                allPlayers.push(player);
+                if (this.collectedEnterElements.length) {
+                    const details = element[REMOVAL_FLAG];
+                    // animations for move operations (elements being removed and reinserted,
+                    // e.g. when the order of an *ngFor list changes) are currently not supported
+                    if (details && details.setForMove) {
+                        if (details.previousTriggersValues &&
+                            details.previousTriggersValues.has(entry.triggerName)) {
+                            const previousValue = details.previousTriggersValues.get(entry.triggerName);
+                            // we need to restore the previous trigger value since the element has
+                            // only been moved and hasn't actually left the DOM
+                            const triggersWithStates = this.statesByElement.get(entry.element);
+                            if (triggersWithStates && triggersWithStates.has(entry.triggerName)) {
+                                const state = triggersWithStates.get(entry.triggerName);
+                                state.value = previousValue;
+                                triggersWithStates.set(entry.triggerName, state);
+                            }
+                        }
+                        player.destroy();
+                        return;
+                    }
+                }
+                const nodeIsOrphaned = !bodyNode || !this.driver.containsElement(bodyNode, element);
+                const leaveClassName = leaveNodeMapIds.get(element);
+                const enterClassName = enterNodeMapIds.get(element);
+                const instruction = this._buildInstruction(entry, subTimelines, enterClassName, leaveClassName, nodeIsOrphaned);
+                if (instruction.errors && instruction.errors.length) {
+                    erroneousTransitions.push(instruction);
+                    return;
+                }
+                // even though the element may not be in the DOM, it may still
+                // be added at a later point (due to the mechanics of content
+                // projection and/or dynamic component insertion) therefore it's
+                // important to still style the element.
+                if (nodeIsOrphaned) {
+                    player.onStart(() => eraseStyles(element, instruction.fromStyles));
+                    player.onDestroy(() => setStyles(element, instruction.toStyles));
+                    skippedPlayers.push(player);
+                    return;
+                }
+                // if an unmatched transition is queued and ready to go
+                // then it SHOULD NOT render an animation and cancel the
+                // previously running animations.
+                if (entry.isFallbackTransition) {
+                    player.onStart(() => eraseStyles(element, instruction.fromStyles));
+                    player.onDestroy(() => setStyles(element, instruction.toStyles));
+                    skippedPlayers.push(player);
+                    return;
+                }
+                // this means that if a parent animation uses this animation as a sub-trigger
+                // then it will instruct the timeline builder not to add a player delay, but
+                // instead stretch the first keyframe gap until the animation starts. This is
+                // important in order to prevent extra initialization styles from being
+                // required by the user for the animation.
+                const timelines = [];
+                instruction.timelines.forEach((tl) => {
+                    tl.stretchStartingKeyframe = true;
+                    if (!this.disabledNodes.has(tl.element)) {
+                        timelines.push(tl);
+                    }
+                });
+                instruction.timelines = timelines;
+                subTimelines.append(element, instruction.timelines);
+                const tuple = { instruction, player, element };
+                queuedInstructions.push(tuple);
+                instruction.queriedElements.forEach((element) => getOrSetDefaultValue(queriedElements, element, []).push(player));
+                instruction.preStyleProps.forEach((stringMap, element) => {
+                    if (stringMap.size) {
+                        let setVal = allPreStyleElements.get(element);
+                        if (!setVal) {
+                            allPreStyleElements.set(element, (setVal = new Set()));
+                        }
+                        stringMap.forEach((_, prop) => setVal.add(prop));
+                    }
+                });
+                instruction.postStyleProps.forEach((stringMap, element) => {
+                    let setVal = allPostStyleElements.get(element);
+                    if (!setVal) {
+                        allPostStyleElements.set(element, (setVal = new Set()));
+                    }
+                    stringMap.forEach((_, prop) => setVal.add(prop));
+                });
+            });
+        }
+        if (erroneousTransitions.length) {
+            const errors = [];
+            erroneousTransitions.forEach((instruction) => {
+                errors.push(transitionFailed(instruction.triggerName, instruction.errors));
+            });
+            allPlayers.forEach((player) => player.destroy());
+            this.reportError(errors);
+        }
+        const allPreviousPlayersMap = new Map();
+        // this map tells us which element in the DOM tree is contained by
+        // which animation. Further down this map will get populated once
+        // the players are built and in doing so we can use it to efficiently
+        // figure out if a sub player is skipped due to a parent player having priority.
+        const animationElementMap = new Map();
+        queuedInstructions.forEach((entry) => {
+            const element = entry.element;
+            if (subTimelines.has(element)) {
+                animationElementMap.set(element, element);
+                this._beforeAnimationBuild(entry.player.namespaceId, entry.instruction, allPreviousPlayersMap);
+            }
+        });
+        skippedPlayers.forEach((player) => {
+            const element = player.element;
+            const previousPlayers = this._getPreviousPlayers(element, false, player.namespaceId, player.triggerName, null);
+            previousPlayers.forEach((prevPlayer) => {
+                getOrSetDefaultValue(allPreviousPlayersMap, element, []).push(prevPlayer);
+                prevPlayer.destroy();
+            });
+        });
+        // this is a special case for nodes that will be removed either by
+        // having their own leave animations or by being queried in a container
+        // that will be removed once a parent animation is complete. The idea
+        // here is that * styles must be identical to ! styles because of
+        // backwards compatibility (* is also filled in by default in many places).
+        // Otherwise * styles will return an empty value or "auto" since the element
+        // passed to getComputedStyle will not be visible (since * === destination)
+        const replaceNodes = allLeaveNodes.filter((node) => {
+            return replacePostStylesAsPre(node, allPreStyleElements, allPostStyleElements);
+        });
+        // POST STAGE: fill the * styles
+        const postStylesMap = new Map();
+        const allLeaveQueriedNodes = cloakAndComputeStyles(postStylesMap, this.driver, leaveNodesWithoutAnimations, allPostStyleElements, AUTO_STYLE);
+        allLeaveQueriedNodes.forEach((node) => {
+            if (replacePostStylesAsPre(node, allPreStyleElements, allPostStyleElements)) {
+                replaceNodes.push(node);
+            }
+        });
+        // PRE STAGE: fill the ! styles
+        const preStylesMap = new Map();
+        enterNodeMap.forEach((nodes, root) => {
+            cloakAndComputeStyles(preStylesMap, this.driver, new Set(nodes), allPreStyleElements, _PRE_STYLE);
+        });
+        replaceNodes.forEach((node) => {
+            const post = postStylesMap.get(node);
+            const pre = preStylesMap.get(node);
+            postStylesMap.set(node, new Map([...(post?.entries() ?? []), ...(pre?.entries() ?? [])]));
+        });
+        const rootPlayers = [];
+        const subPlayers = [];
+        const NO_PARENT_ANIMATION_ELEMENT_DETECTED = {};
+        queuedInstructions.forEach((entry) => {
+            const { element, player, instruction } = entry;
+            // this means that it was never consumed by a parent animation which
+            // means that it is independent and therefore should be set for animation
+            if (subTimelines.has(element)) {
+                if (disabledElementsSet.has(element)) {
+                    player.onDestroy(() => setStyles(element, instruction.toStyles));
+                    player.disabled = true;
+                    player.overrideTotalTime(instruction.totalTime);
+                    skippedPlayers.push(player);
+                    return;
+                }
+                // this will flow up the DOM and query the map to figure out
+                // if a parent animation has priority over it. In the situation
+                // that a parent is detected then it will cancel the loop. If
+                // nothing is detected, or it takes a few hops to find a parent,
+                // then it will fill in the missing nodes and signal them as having
+                // a detected parent (or a NO_PARENT value via a special constant).
+                let parentWithAnimation = NO_PARENT_ANIMATION_ELEMENT_DETECTED;
+                if (animationElementMap.size > 1) {
+                    let elm = element;
+                    const parentsToAdd = [];
+                    while ((elm = elm.parentNode)) {
+                        const detectedParent = animationElementMap.get(elm);
+                        if (detectedParent) {
+                            parentWithAnimation = detectedParent;
+                            break;
+                        }
+                        parentsToAdd.push(elm);
+                    }
+                    parentsToAdd.forEach((parent) => animationElementMap.set(parent, parentWithAnimation));
+                }
+                const innerPlayer = this._buildAnimation(player.namespaceId, instruction, allPreviousPlayersMap, skippedPlayersMap, preStylesMap, postStylesMap);
+                player.setRealPlayer(innerPlayer);
+                if (parentWithAnimation === NO_PARENT_ANIMATION_ELEMENT_DETECTED) {
+                    rootPlayers.push(player);
+                }
+                else {
+                    const parentPlayers = this.playersByElement.get(parentWithAnimation);
+                    if (parentPlayers && parentPlayers.length) {
+                        player.parentPlayer = optimizeGroupPlayer(parentPlayers);
+                    }
+                    skippedPlayers.push(player);
+                }
+            }
+            else {
+                eraseStyles(element, instruction.fromStyles);
+                player.onDestroy(() => setStyles(element, instruction.toStyles));
+                // there still might be a ancestor player animating this
+                // element therefore we will still add it as a sub player
+                // even if its animation may be disabled
+                subPlayers.push(player);
+                if (disabledElementsSet.has(element)) {
+                    skippedPlayers.push(player);
+                }
+            }
+        });
+        // find all of the sub players' corresponding inner animation players
+        subPlayers.forEach((player) => {
+            // even if no players are found for a sub animation it
+            // will still complete itself after the next tick since it's Noop
+            const playersForElement = skippedPlayersMap.get(player.element);
+            if (playersForElement && playersForElement.length) {
+                const innerPlayer = optimizeGroupPlayer(playersForElement);
+                player.setRealPlayer(innerPlayer);
+            }
+        });
+        // the reason why we don't actually play the animation is
+        // because all that a skipped player is designed to do is to
+        // fire the start/done transition callback events
+        skippedPlayers.forEach((player) => {
+            if (player.parentPlayer) {
+                player.syncPlayerEvents(player.parentPlayer);
+            }
+            else {
+                player.destroy();
+            }
+        });
+        // run through all of the queued removals and see if they
+        // were picked up by a query. If not then perform the removal
+        // operation right away unless a parent animation is ongoing.
+        for (let i = 0; i < allLeaveNodes.length; i++) {
+            const element = allLeaveNodes[i];
+            const details = element[REMOVAL_FLAG];
+            removeClass(element, LEAVE_CLASSNAME);
+            // this means the element has a removal animation that is being
+            // taken care of and therefore the inner elements will hang around
+            // until that animation is over (or the parent queried animation)
+            if (details && details.hasAnimation)
+                continue;
+            let players = [];
+            // if this element is queried or if it contains queried children
+            // then we want for the element not to be removed from the page
+            // until the queried animations have finished
+            if (queriedElements.size) {
+                let queriedPlayerResults = queriedElements.get(element);
+                if (queriedPlayerResults && queriedPlayerResults.length) {
+                    players.push(...queriedPlayerResults);
+                }
+                let queriedInnerElements = this.driver.query(element, NG_ANIMATING_SELECTOR, true);
+                for (let j = 0; j < queriedInnerElements.length; j++) {
+                    let queriedPlayers = queriedElements.get(queriedInnerElements[j]);
+                    if (queriedPlayers && queriedPlayers.length) {
+                        players.push(...queriedPlayers);
+                    }
+                }
+            }
+            const activePlayers = players.filter((p) => !p.destroyed);
+            if (activePlayers.length) {
+                removeNodesAfterAnimationDone(this, element, activePlayers);
+            }
+            else {
+                this.processLeaveNode(element);
+            }
+        }
+        // this is required so the cleanup method doesn't remove them
+        allLeaveNodes.length = 0;
+        rootPlayers.forEach((player) => {
+            this.players.push(player);
+            player.onDone(() => {
+                player.destroy();
+                const index = this.players.indexOf(player);
+                this.players.splice(index, 1);
+            });
+            player.play();
+        });
+        return rootPlayers;
+    }
+    afterFlush(callback) {
+        this._flushFns.push(callback);
+    }
+    afterFlushAnimationsDone(callback) {
+        this._whenQuietFns.push(callback);
+    }
+    _getPreviousPlayers(element, isQueriedElement, namespaceId, triggerName, toStateValue) {
+        let players = [];
+        if (isQueriedElement) {
+            const queriedElementPlayers = this.playersByQueriedElement.get(element);
+            if (queriedElementPlayers) {
+                players = queriedElementPlayers;
+            }
+        }
+        else {
+            const elementPlayers = this.playersByElement.get(element);
+            if (elementPlayers) {
+                const isRemovalAnimation = !toStateValue || toStateValue == VOID_VALUE;
+                elementPlayers.forEach((player) => {
+                    if (player.queued)
+                        return;
+                    if (!isRemovalAnimation && player.triggerName != triggerName)
+                        return;
+                    players.push(player);
+                });
+            }
+        }
+        if (namespaceId || triggerName) {
+            players = players.filter((player) => {
+                if (namespaceId && namespaceId != player.namespaceId)
+                    return false;
+                if (triggerName && triggerName != player.triggerName)
+                    return false;
+                return true;
+            });
+        }
+        return players;
+    }
+    _beforeAnimationBuild(namespaceId, instruction, allPreviousPlayersMap) {
+        const triggerName = instruction.triggerName;
+        const rootElement = instruction.element;
+        // when a removal animation occurs, ALL previous players are collected
+        // and destroyed (even if they are outside of the current namespace)
+        const targetNameSpaceId = instruction.isRemovalTransition
+            ? undefined
+            : namespaceId;
+        const targetTriggerName = instruction.isRemovalTransition
+            ? undefined
+            : triggerName;
+        for (const timelineInstruction of instruction.timelines) {
+            const element = timelineInstruction.element;
+            const isQueriedElement = element !== rootElement;
+            const players = getOrSetDefaultValue(allPreviousPlayersMap, element, []);
+            const previousPlayers = this._getPreviousPlayers(element, isQueriedElement, targetNameSpaceId, targetTriggerName, instruction.toState);
+            previousPlayers.forEach((player) => {
+                const realPlayer = player.getRealPlayer();
+                if (realPlayer.beforeDestroy) {
+                    realPlayer.beforeDestroy();
+                }
+                player.destroy();
+                players.push(player);
+            });
+        }
+        // this needs to be done so that the PRE/POST styles can be
+        // computed properly without interfering with the previous animation
+        eraseStyles(rootElement, instruction.fromStyles);
+    }
+    _buildAnimation(namespaceId, instruction, allPreviousPlayersMap, skippedPlayersMap, preStylesMap, postStylesMap) {
+        const triggerName = instruction.triggerName;
+        const rootElement = instruction.element;
+        // we first run this so that the previous animation player
+        // data can be passed into the successive animation players
+        const allQueriedPlayers = [];
+        const allConsumedElements = new Set();
+        const allSubElements = new Set();
+        const allNewPlayers = instruction.timelines.map((timelineInstruction) => {
+            const element = timelineInstruction.element;
+            allConsumedElements.add(element);
+            // FIXME (matsko): make sure to-be-removed animations are removed properly
+            const details = element[REMOVAL_FLAG];
+            if (details && details.removedBeforeQueried)
+                return new NoopAnimationPlayer(timelineInstruction.duration, timelineInstruction.delay);
+            const isQueriedElement = element !== rootElement;
+            const previousPlayers = flattenGroupPlayers((allPreviousPlayersMap.get(element) || EMPTY_PLAYER_ARRAY).map((p) => p.getRealPlayer())).filter((p) => {
+                // the `element` is not apart of the AnimationPlayer definition, but
+                // Mock/WebAnimations
+                // use the element within their implementation. This will be added in Angular5 to
+                // AnimationPlayer
+                const pp = p;
+                return pp.element ? pp.element === element : false;
+            });
+            const preStyles = preStylesMap.get(element);
+            const postStyles = postStylesMap.get(element);
+            const keyframes = normalizeKeyframes(this._normalizer, timelineInstruction.keyframes, preStyles, postStyles);
+            const player = this._buildPlayer(timelineInstruction, keyframes, previousPlayers);
+            // this means that this particular player belongs to a sub trigger. It is
+            // important that we match this player up with the corresponding (@trigger.listener)
+            if (timelineInstruction.subTimeline && skippedPlayersMap) {
+                allSubElements.add(element);
+            }
+            if (isQueriedElement) {
+                const wrappedPlayer = new TransitionAnimationPlayer(namespaceId, triggerName, element);
+                wrappedPlayer.setRealPlayer(player);
+                allQueriedPlayers.push(wrappedPlayer);
+            }
+            return player;
+        });
+        allQueriedPlayers.forEach((player) => {
+            getOrSetDefaultValue(this.playersByQueriedElement, player.element, []).push(player);
+            player.onDone(() => deleteOrUnsetInMap(this.playersByQueriedElement, player.element, player));
+        });
+        allConsumedElements.forEach((element) => addClass(element, NG_ANIMATING_CLASSNAME));
+        const player = optimizeGroupPlayer(allNewPlayers);
+        player.onDestroy(() => {
+            allConsumedElements.forEach((element) => removeClass(element, NG_ANIMATING_CLASSNAME));
+            setStyles(rootElement, instruction.toStyles);
+        });
+        // this basically makes all of the callbacks for sub element animations
+        // be dependent on the upper players for when they finish
+        allSubElements.forEach((element) => {
+            getOrSetDefaultValue(skippedPlayersMap, element, []).push(player);
+        });
+        return player;
+    }
+    _buildPlayer(instruction, keyframes, previousPlayers) {
+        if (keyframes.length > 0) {
+            return this.driver.animate(instruction.element, keyframes, instruction.duration, instruction.delay, instruction.easing, previousPlayers);
+        }
+        // special case for when an empty transition|definition is provided
+        // ... there is no point in rendering an empty animation
+        return new NoopAnimationPlayer(instruction.duration, instruction.delay);
+    }
+}
+class TransitionAnimationPlayer {
+    namespaceId;
+    triggerName;
+    element;
+    _player = new NoopAnimationPlayer();
+    _containsRealPlayer = false;
+    _queuedCallbacks = new Map();
+    destroyed = false;
+    parentPlayer = null;
+    markedForDestroy = false;
+    disabled = false;
+    queued = true;
+    totalTime = 0;
+    constructor(namespaceId, triggerName, element) {
+        this.namespaceId = namespaceId;
+        this.triggerName = triggerName;
+        this.element = element;
+    }
+    setRealPlayer(player) {
+        if (this._containsRealPlayer)
+            return;
+        this._player = player;
+        this._queuedCallbacks.forEach((callbacks, phase) => {
+            callbacks.forEach((callback) => listenOnPlayer(player, phase, undefined, callback));
+        });
+        this._queuedCallbacks.clear();
+        this._containsRealPlayer = true;
+        this.overrideTotalTime(player.totalTime);
+        this.queued = false;
+    }
+    getRealPlayer() {
+        return this._player;
+    }
+    overrideTotalTime(totalTime) {
+        this.totalTime = totalTime;
+    }
+    syncPlayerEvents(player) {
+        const p = this._player;
+        if (p.triggerCallback) {
+            player.onStart(() => p.triggerCallback('start'));
+        }
+        player.onDone(() => this.finish());
+        player.onDestroy(() => this.destroy());
+    }
+    _queueEvent(name, callback) {
+        getOrSetDefaultValue(this._queuedCallbacks, name, []).push(callback);
+    }
+    onDone(fn) {
+        if (this.queued) {
+            this._queueEvent('done', fn);
+        }
+        this._player.onDone(fn);
+    }
+    onStart(fn) {
+        if (this.queued) {
+            this._queueEvent('start', fn);
+        }
+        this._player.onStart(fn);
+    }
+    onDestroy(fn) {
+        if (this.queued) {
+            this._queueEvent('destroy', fn);
+        }
+        this._player.onDestroy(fn);
+    }
+    init() {
+        this._player.init();
+    }
+    hasStarted() {
+        return this.queued ? false : this._player.hasStarted();
+    }
+    play() {
+        !this.queued && this._player.play();
+    }
+    pause() {
+        !this.queued && this._player.pause();
+    }
+    restart() {
+        !this.queued && this._player.restart();
+    }
+    finish() {
+        this._player.finish();
+    }
+    destroy() {
+        this.destroyed = true;
+        this._player.destroy();
+    }
+    reset() {
+        !this.queued && this._player.reset();
+    }
+    setPosition(p) {
+        if (!this.queued) {
+            this._player.setPosition(p);
+        }
+    }
+    getPosition() {
+        return this.queued ? 0 : this._player.getPosition();
+    }
+    /** @internal */
+    triggerCallback(phaseName) {
+        const p = this._player;
+        if (p.triggerCallback) {
+            p.triggerCallback(phaseName);
+        }
+    }
+}
+function deleteOrUnsetInMap(map, key, value) {
+    let currentValues = map.get(key);
+    if (currentValues) {
+        if (currentValues.length) {
+            const index = currentValues.indexOf(value);
+            currentValues.splice(index, 1);
+        }
+        if (currentValues.length == 0) {
+            map.delete(key);
+        }
+    }
+    return currentValues;
+}
+function normalizeTriggerValue(value) {
+    // we use `!= null` here because it's the most simple
+    // way to test against a "falsy" value without mixing
+    // in empty strings or a zero value. DO NOT OPTIMIZE.
+    return value != null ? value : null;
+}
+function isElementNode(node) {
+    return node && node['nodeType'] === 1;
+}
+function isTriggerEventValid(eventName) {
+    return eventName == 'start' || eventName == 'done';
+}
+function cloakElement(element, value) {
+    const oldValue = element.style.display;
+    element.style.display = value != null ? value : 'none';
+    return oldValue;
+}
+function cloakAndComputeStyles(valuesMap, driver, elements, elementPropsMap, defaultStyle) {
+    const cloakVals = [];
+    elements.forEach((element) => cloakVals.push(cloakElement(element)));
+    const failedElements = [];
+    elementPropsMap.forEach((props, element) => {
+        const styles = new Map();
+        props.forEach((prop) => {
+            const value = driver.computeStyle(element, prop, defaultStyle);
+            styles.set(prop, value);
+            // there is no easy way to detect this because a sub element could be removed
+            // by a parent animation element being detached.
+            if (!value || value.length == 0) {
+                element[REMOVAL_FLAG] = NULL_REMOVED_QUERIED_STATE;
+                failedElements.push(element);
+            }
+        });
+        valuesMap.set(element, styles);
+    });
+    // we use a index variable here since Set.forEach(a, i) does not return
+    // an index value for the closure (but instead just the value)
+    let i = 0;
+    elements.forEach((element) => cloakElement(element, cloakVals[i++]));
+    return failedElements;
+}
+/*
+Since the Angular renderer code will return a collection of inserted
+nodes in all areas of a DOM tree, it's up to this algorithm to figure
+out which nodes are roots for each animation @trigger.
+
+By placing each inserted node into a Set and traversing upwards, it
+is possible to find the @trigger elements and well any direct *star
+insertion nodes, if a @trigger root is found then the enter element
+is placed into the Map[@trigger] spot.
+ */
+function buildRootMap(roots, nodes) {
+    const rootMap = new Map();
+    roots.forEach((root) => rootMap.set(root, []));
+    if (nodes.length == 0)
+        return rootMap;
+    const NULL_NODE = 1;
+    const nodeSet = new Set(nodes);
+    const localRootMap = new Map();
+    function getRoot(node) {
+        if (!node)
+            return NULL_NODE;
+        let root = localRootMap.get(node);
+        if (root)
+            return root;
+        const parent = node.parentNode;
+        if (rootMap.has(parent)) {
+            // ngIf inside @trigger
+            root = parent;
+        }
+        else if (nodeSet.has(parent)) {
+            // ngIf inside ngIf
+            root = NULL_NODE;
+        }
+        else {
+            // recurse upwards
+            root = getRoot(parent);
+        }
+        localRootMap.set(node, root);
+        return root;
+    }
+    nodes.forEach((node) => {
+        const root = getRoot(node);
+        if (root !== NULL_NODE) {
+            rootMap.get(root).push(node);
+        }
+    });
+    return rootMap;
+}
+function addClass(element, className) {
+    element.classList?.add(className);
+}
+function removeClass(element, className) {
+    element.classList?.remove(className);
+}
+function removeNodesAfterAnimationDone(engine, element, players) {
+    optimizeGroupPlayer(players).onDone(() => engine.processLeaveNode(element));
+}
+function flattenGroupPlayers(players) {
+    const finalPlayers = [];
+    _flattenGroupPlayersRecur(players, finalPlayers);
+    return finalPlayers;
+}
+function _flattenGroupPlayersRecur(players, finalPlayers) {
+    for (let i = 0; i < players.length; i++) {
+        const player = players[i];
+        if (player instanceof AnimationGroupPlayer) {
+            _flattenGroupPlayersRecur(player.players, finalPlayers);
+        }
+        else {
+            finalPlayers.push(player);
+        }
+    }
+}
+function objEquals(a, b) {
+    const k1 = Object.keys(a);
+    const k2 = Object.keys(b);
+    if (k1.length != k2.length)
+        return false;
+    for (let i = 0; i < k1.length; i++) {
+        const prop = k1[i];
+        if (!b.hasOwnProperty(prop) || a[prop] !== b[prop])
+            return false;
+    }
+    return true;
+}
+function replacePostStylesAsPre(element, allPreStyleElements, allPostStyleElements) {
+    const postEntry = allPostStyleElements.get(element);
+    if (!postEntry)
+        return false;
+    let preEntry = allPreStyleElements.get(element);
+    if (preEntry) {
+        postEntry.forEach((data) => preEntry.add(data));
+    }
+    else {
+        allPreStyleElements.set(element, postEntry);
+    }
+    allPostStyleElements.delete(element);
+    return true;
+}
+
+class AnimationEngine {
+    _driver;
+    _normalizer;
+    _transitionEngine;
+    _timelineEngine;
+    _triggerCache = {};
+    // this method is designed to be overridden by the code that uses this engine
+    onRemovalComplete = (element, context) => { };
+    constructor(doc, _driver, _normalizer) {
+        this._driver = _driver;
+        this._normalizer = _normalizer;
+        this._transitionEngine = new TransitionAnimationEngine(doc.body, _driver, _normalizer);
+        this._timelineEngine = new TimelineAnimationEngine(doc.body, _driver, _normalizer);
+        this._transitionEngine.onRemovalComplete = (element, context) => this.onRemovalComplete(element, context);
+    }
+    registerTrigger(componentId, namespaceId, hostElement, name, metadata) {
+        const cacheKey = componentId + '-' + name;
+        let trigger = this._triggerCache[cacheKey];
+        if (!trigger) {
+            const errors = [];
+            const warnings = [];
+            const ast = buildAnimationAst(this._driver, metadata, errors, warnings);
+            if (errors.length) {
+                throw triggerBuildFailed(name, errors);
+            }
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                if (warnings.length) {
+                    warnTriggerBuild(name, warnings);
+                }
+            }
+            trigger = buildTrigger(name, ast, this._normalizer);
+            this._triggerCache[cacheKey] = trigger;
+        }
+        this._transitionEngine.registerTrigger(namespaceId, name, trigger);
+    }
+    register(namespaceId, hostElement) {
+        this._transitionEngine.register(namespaceId, hostElement);
+    }
+    destroy(namespaceId, context) {
+        this._transitionEngine.destroy(namespaceId, context);
+    }
+    onInsert(namespaceId, element, parent, insertBefore) {
+        this._transitionEngine.insertNode(namespaceId, element, parent, insertBefore);
+    }
+    onRemove(namespaceId, element, context) {
+        this._transitionEngine.removeNode(namespaceId, element, context);
+    }
+    disableAnimations(element, disable) {
+        this._transitionEngine.markElementAsDisabled(element, disable);
+    }
+    process(namespaceId, element, property, value) {
+        if (property.charAt(0) == '@') {
+            const [id, action] = parseTimelineCommand(property);
+            const args = value;
+            this._timelineEngine.command(id, element, action, args);
+        }
+        else {
+            this._transitionEngine.trigger(namespaceId, element, property, value);
+        }
+    }
+    listen(namespaceId, element, eventName, eventPhase, callback) {
+        // @@listen
+        if (eventName.charAt(0) == '@') {
+            const [id, action] = parseTimelineCommand(eventName);
+            return this._timelineEngine.listen(id, element, action, callback);
+        }
+        return this._transitionEngine.listen(namespaceId, element, eventName, eventPhase, callback);
+    }
+    flush(microtaskId = -1) {
+        this._transitionEngine.flush(microtaskId);
+    }
+    get players() {
+        return [...this._transitionEngine.players, ...this._timelineEngine.players];
+    }
+    whenRenderingDone() {
+        return this._transitionEngine.whenRenderingDone();
+    }
+    afterFlushAnimationsDone(cb) {
+        this._transitionEngine.afterFlushAnimationsDone(cb);
+    }
+}
+
+/**
+ * Returns an instance of `SpecialCasedStyles` if and when any special (non animateable) styles are
+ * detected.
+ *
+ * In CSS there exist properties that cannot be animated within a keyframe animation
+ * (whether it be via CSS keyframes or web-animations) and the animation implementation
+ * will ignore them. This function is designed to detect those special cased styles and
+ * return a container that will be executed at the start and end of the animation.
+ *
+ * @returns an instance of `SpecialCasedStyles` if any special styles are detected otherwise `null`
+ */
+function packageNonAnimatableStyles(element, styles) {
+    let startStyles = null;
+    let endStyles = null;
+    if (Array.isArray(styles) && styles.length) {
+        startStyles = filterNonAnimatableStyles(styles[0]);
+        if (styles.length > 1) {
+            endStyles = filterNonAnimatableStyles(styles[styles.length - 1]);
+        }
+    }
+    else if (styles instanceof Map) {
+        startStyles = filterNonAnimatableStyles(styles);
+    }
+    return startStyles || endStyles ? new SpecialCasedStyles(element, startStyles, endStyles) : null;
+}
+/**
+ * Designed to be executed during a keyframe-based animation to apply any special-cased styles.
+ *
+ * When started (when the `start()` method is run) then the provided `startStyles`
+ * will be applied. When finished (when the `finish()` method is called) the
+ * `endStyles` will be applied as well any any starting styles. Finally when
+ * `destroy()` is called then all styles will be removed.
+ */
+class SpecialCasedStyles {
+    _element;
+    _startStyles;
+    _endStyles;
+    static initialStylesByElement = /* @__PURE__ */ new WeakMap();
+    _state = 0 /* SpecialCasedStylesState.Pending */;
+    _initialStyles;
+    constructor(_element, _startStyles, _endStyles) {
+        this._element = _element;
+        this._startStyles = _startStyles;
+        this._endStyles = _endStyles;
+        let initialStyles = SpecialCasedStyles.initialStylesByElement.get(_element);
+        if (!initialStyles) {
+            SpecialCasedStyles.initialStylesByElement.set(_element, (initialStyles = new Map()));
+        }
+        this._initialStyles = initialStyles;
+    }
+    start() {
+        if (this._state < 1 /* SpecialCasedStylesState.Started */) {
+            if (this._startStyles) {
+                setStyles(this._element, this._startStyles, this._initialStyles);
+            }
+            this._state = 1 /* SpecialCasedStylesState.Started */;
+        }
+    }
+    finish() {
+        this.start();
+        if (this._state < 2 /* SpecialCasedStylesState.Finished */) {
+            setStyles(this._element, this._initialStyles);
+            if (this._endStyles) {
+                setStyles(this._element, this._endStyles);
+                this._endStyles = null;
+            }
+            this._state = 1 /* SpecialCasedStylesState.Started */;
+        }
+    }
+    destroy() {
+        this.finish();
+        if (this._state < 3 /* SpecialCasedStylesState.Destroyed */) {
+            SpecialCasedStyles.initialStylesByElement.delete(this._element);
+            if (this._startStyles) {
+                eraseStyles(this._element, this._startStyles);
+                this._endStyles = null;
+            }
+            if (this._endStyles) {
+                eraseStyles(this._element, this._endStyles);
+                this._endStyles = null;
+            }
+            setStyles(this._element, this._initialStyles);
+            this._state = 3 /* SpecialCasedStylesState.Destroyed */;
+        }
+    }
+}
+function filterNonAnimatableStyles(styles) {
+    let result = null;
+    styles.forEach((val, prop) => {
+        if (isNonAnimatableStyle(prop)) {
+            result = result || new Map();
+            result.set(prop, val);
+        }
+    });
+    return result;
+}
+function isNonAnimatableStyle(prop) {
+    return prop === 'display' || prop === 'position';
+}
+
+class WebAnimationsPlayer {
+    element;
+    keyframes;
+    options;
+    _specialStyles;
+    _onDoneFns = [];
+    _onStartFns = [];
+    _onDestroyFns = [];
+    _duration;
+    _delay;
+    _initialized = false;
+    _finished = false;
+    _started = false;
+    _destroyed = false;
+    _finalKeyframe;
+    // the following original fns are persistent copies of the _onStartFns and _onDoneFns
+    // and are used to reset the fns to their original values upon reset()
+    // (since the _onStartFns and _onDoneFns get deleted after they are called)
+    _originalOnDoneFns = [];
+    _originalOnStartFns = [];
+    // using non-null assertion because it's re(set) by init();
+    domPlayer;
+    time = 0;
+    parentPlayer = null;
+    currentSnapshot = new Map();
+    constructor(element, keyframes, options, _specialStyles) {
+        this.element = element;
+        this.keyframes = keyframes;
+        this.options = options;
+        this._specialStyles = _specialStyles;
+        this._duration = options['duration'];
+        this._delay = options['delay'] || 0;
+        this.time = this._duration + this._delay;
+    }
+    _onFinish() {
+        if (!this._finished) {
+            this._finished = true;
+            this._onDoneFns.forEach((fn) => fn());
+            this._onDoneFns = [];
+        }
+    }
+    init() {
+        this._buildPlayer();
+        this._preparePlayerBeforeStart();
+    }
+    _buildPlayer() {
+        if (this._initialized)
+            return;
+        this._initialized = true;
+        const keyframes = this.keyframes;
+        // @ts-expect-error overwriting a readonly property
+        this.domPlayer = this._triggerWebAnimation(this.element, keyframes, this.options);
+        this._finalKeyframe = keyframes.length ? keyframes[keyframes.length - 1] : new Map();
+        const onFinish = () => this._onFinish();
+        this.domPlayer.addEventListener('finish', onFinish);
+        this.onDestroy(() => {
+            // We must remove the `finish` event listener once an animation has completed all its
+            // iterations. This action is necessary to prevent a memory leak since the listener captures
+            // `this`, creating a closure that prevents `this` from being garbage collected.
+            this.domPlayer.removeEventListener('finish', onFinish);
+        });
+    }
+    _preparePlayerBeforeStart() {
+        // this is required so that the player doesn't start to animate right away
+        if (this._delay) {
+            this._resetDomPlayerState();
+        }
+        else {
+            this.domPlayer.pause();
+        }
+    }
+    _convertKeyframesToObject(keyframes) {
+        const kfs = [];
+        keyframes.forEach((frame) => {
+            kfs.push(Object.fromEntries(frame));
+        });
+        return kfs;
+    }
+    /** @internal */
+    _triggerWebAnimation(element, keyframes, options) {
+        return element.animate(this._convertKeyframesToObject(keyframes), options);
+    }
+    onStart(fn) {
+        this._originalOnStartFns.push(fn);
+        this._onStartFns.push(fn);
+    }
+    onDone(fn) {
+        this._originalOnDoneFns.push(fn);
+        this._onDoneFns.push(fn);
+    }
+    onDestroy(fn) {
+        this._onDestroyFns.push(fn);
+    }
+    play() {
+        this._buildPlayer();
+        if (!this.hasStarted()) {
+            this._onStartFns.forEach((fn) => fn());
+            this._onStartFns = [];
+            this._started = true;
+            if (this._specialStyles) {
+                this._specialStyles.start();
+            }
+        }
+        this.domPlayer.play();
+    }
+    pause() {
+        this.init();
+        this.domPlayer.pause();
+    }
+    finish() {
+        this.init();
+        if (this._specialStyles) {
+            this._specialStyles.finish();
+        }
+        this._onFinish();
+        this.domPlayer.finish();
+    }
+    reset() {
+        this._resetDomPlayerState();
+        this._destroyed = false;
+        this._finished = false;
+        this._started = false;
+        this._onStartFns = this._originalOnStartFns;
+        this._onDoneFns = this._originalOnDoneFns;
+    }
+    _resetDomPlayerState() {
+        if (this.domPlayer) {
+            this.domPlayer.cancel();
+        }
+    }
+    restart() {
+        this.reset();
+        this.play();
+    }
+    hasStarted() {
+        return this._started;
+    }
+    destroy() {
+        if (!this._destroyed) {
+            this._destroyed = true;
+            this._resetDomPlayerState();
+            this._onFinish();
+            if (this._specialStyles) {
+                this._specialStyles.destroy();
+            }
+            this._onDestroyFns.forEach((fn) => fn());
+            this._onDestroyFns = [];
+        }
+    }
+    setPosition(p) {
+        if (this.domPlayer === undefined) {
+            this.init();
+        }
+        this.domPlayer.currentTime = p * this.time;
+    }
+    getPosition() {
+        // tsc is complaining with TS2362 without the conversion to number
+        return +(this.domPlayer.currentTime ?? 0) / this.time;
+    }
+    get totalTime() {
+        return this._delay + this._duration;
+    }
+    beforeDestroy() {
+        const styles = new Map();
+        if (this.hasStarted()) {
+            // note: this code is invoked only when the `play` function was called prior to this
+            // (thus `hasStarted` returns true), this implies that the code that initializes
+            // `_finalKeyframe` has also been executed and the non-null assertion can be safely used here
+            const finalKeyframe = this._finalKeyframe;
+            finalKeyframe.forEach((val, prop) => {
+                if (prop !== 'offset') {
+                    styles.set(prop, this._finished ? val : computeStyle(this.element, prop));
+                }
+            });
+        }
+        this.currentSnapshot = styles;
+    }
+    /** @internal */
+    triggerCallback(phaseName) {
+        const methods = phaseName === 'start' ? this._onStartFns : this._onDoneFns;
+        methods.forEach((fn) => fn());
+        methods.length = 0;
+    }
+}
+
+class WebAnimationsDriver {
+    validateStyleProperty(prop) {
+        // Perform actual validation in dev mode only, in prod mode this check is a noop.
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            return validateStyleProperty(prop);
+        }
+        return true;
+    }
+    validateAnimatableStyleProperty(prop) {
+        // Perform actual validation in dev mode only, in prod mode this check is a noop.
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            const cssProp = camelCaseToDashCase(prop);
+            return validateWebAnimatableStyleProperty(cssProp);
+        }
+        return true;
+    }
+    containsElement(elm1, elm2) {
+        return containsElement(elm1, elm2);
+    }
+    getParentElement(element) {
+        return getParentElement(element);
+    }
+    query(element, selector, multi) {
+        return invokeQuery(element, selector, multi);
+    }
+    computeStyle(element, prop, defaultValue) {
+        return computeStyle(element, prop);
+    }
+    animate(element, keyframes, duration, delay, easing, previousPlayers = []) {
+        const fill = delay == 0 ? 'both' : 'forwards';
+        const playerOptions = { duration, delay, fill };
+        // we check for this to avoid having a null|undefined value be present
+        // for the easing (which results in an error for certain browsers #9752)
+        if (easing) {
+            playerOptions['easing'] = easing;
+        }
+        const previousStyles = new Map();
+        const previousWebAnimationPlayers = (previousPlayers.filter((player) => player instanceof WebAnimationsPlayer));
+        if (allowPreviousPlayerStylesMerge(duration, delay)) {
+            previousWebAnimationPlayers.forEach((player) => {
+                player.currentSnapshot.forEach((val, prop) => previousStyles.set(prop, val));
+            });
+        }
+        let _keyframes = normalizeKeyframes$1(keyframes).map((styles) => new Map(styles));
+        _keyframes = balancePreviousStylesIntoKeyframes(element, _keyframes, previousStyles);
+        const specialStyles = packageNonAnimatableStyles(element, _keyframes);
+        return new WebAnimationsPlayer(element, _keyframes, playerOptions, specialStyles);
+    }
+}
+
+function createEngine(type, doc) {
+    // TODO: find a way to make this tree shakable.
+    if (type === 'noop') {
+        return new AnimationEngine(doc, new NoopAnimationDriver(), new NoopAnimationStyleNormalizer());
+    }
+    return new AnimationEngine(doc, new WebAnimationsDriver(), new WebAnimationsStyleNormalizer());
+}
+
+class Animation {
+    _driver;
+    _animationAst;
+    constructor(_driver, input) {
+        this._driver = _driver;
+        const errors = [];
+        const warnings = [];
+        const ast = buildAnimationAst(_driver, input, errors, warnings);
+        if (errors.length) {
+            throw validationFailed(errors);
+        }
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            if (warnings.length) {
+                warnValidation(warnings);
+            }
+        }
+        this._animationAst = ast;
+    }
+    buildTimelines(element, startingStyles, destinationStyles, options, subInstructions) {
+        const start = Array.isArray(startingStyles)
+            ? normalizeStyles(startingStyles)
+            : startingStyles;
+        const dest = Array.isArray(destinationStyles)
+            ? normalizeStyles(destinationStyles)
+            : destinationStyles;
+        const errors = [];
+        subInstructions = subInstructions || new ElementInstructionMap();
+        const result = buildAnimationTimelines(this._driver, element, this._animationAst, ENTER_CLASSNAME, LEAVE_CLASSNAME, start, dest, options, subInstructions, errors);
+        if (errors.length) {
+            throw buildingFailed(errors);
+        }
+        return result;
+    }
+}
+
+const ANIMATION_PREFIX = '@';
+const DISABLE_ANIMATIONS_FLAG = '@.disabled';
+class BaseAnimationRenderer {
+    namespaceId;
+    delegate;
+    engine;
+    _onDestroy;
+    // We need to explicitly type this property because of an api-extractor bug
+    // See https://github.com/microsoft/rushstack/issues/4390
+    ɵtype = 0 /* AnimationRendererType.Regular */;
+    constructor(namespaceId, delegate, engine, _onDestroy) {
+        this.namespaceId = namespaceId;
+        this.delegate = delegate;
+        this.engine = engine;
+        this._onDestroy = _onDestroy;
+    }
+    get data() {
+        return this.delegate.data;
+    }
+    destroyNode(node) {
+        this.delegate.destroyNode?.(node);
+    }
+    destroy() {
+        this.engine.destroy(this.namespaceId, this.delegate);
+        this.engine.afterFlushAnimationsDone(() => {
+            // Call the renderer destroy method after the animations has finished as otherwise
+            // styles will be removed too early which will cause an unstyled animation.
+            queueMicrotask(() => {
+                this.delegate.destroy();
+            });
+        });
+        this._onDestroy?.();
+    }
+    createElement(name, namespace) {
+        return this.delegate.createElement(name, namespace);
+    }
+    createComment(value) {
+        return this.delegate.createComment(value);
+    }
+    createText(value) {
+        return this.delegate.createText(value);
+    }
+    appendChild(parent, newChild) {
+        this.delegate.appendChild(parent, newChild);
+        this.engine.onInsert(this.namespaceId, newChild, parent, false);
+    }
+    insertBefore(parent, newChild, refChild, isMove = true) {
+        this.delegate.insertBefore(parent, newChild, refChild);
+        // If `isMove` true than we should animate this insert.
+        this.engine.onInsert(this.namespaceId, newChild, parent, isMove);
+    }
+    removeChild(parent, oldChild, isHostElement) {
+        // Prior to the changes in #57203, this method wasn't being called at all by `core` if the child
+        // doesn't have a parent. There appears to be some animation-specific downstream logic that
+        // depends on the null check happening before the animation engine. This check keeps the old
+        // behavior while allowing `core` to not have to check for the parent element anymore.
+        if (this.parentNode(oldChild)) {
+            this.engine.onRemove(this.namespaceId, oldChild, this.delegate);
+        }
+    }
+    selectRootElement(selectorOrNode, preserveContent) {
+        return this.delegate.selectRootElement(selectorOrNode, preserveContent);
+    }
+    parentNode(node) {
+        return this.delegate.parentNode(node);
+    }
+    nextSibling(node) {
+        return this.delegate.nextSibling(node);
+    }
+    setAttribute(el, name, value, namespace) {
+        this.delegate.setAttribute(el, name, value, namespace);
+    }
+    removeAttribute(el, name, namespace) {
+        this.delegate.removeAttribute(el, name, namespace);
+    }
+    addClass(el, name) {
+        this.delegate.addClass(el, name);
+    }
+    removeClass(el, name) {
+        this.delegate.removeClass(el, name);
+    }
+    setStyle(el, style, value, flags) {
+        this.delegate.setStyle(el, style, value, flags);
+    }
+    removeStyle(el, style, flags) {
+        this.delegate.removeStyle(el, style, flags);
+    }
+    setProperty(el, name, value) {
+        if (name.charAt(0) == ANIMATION_PREFIX && name == DISABLE_ANIMATIONS_FLAG) {
+            this.disableAnimations(el, !!value);
+        }
+        else {
+            this.delegate.setProperty(el, name, value);
+        }
+    }
+    setValue(node, value) {
+        this.delegate.setValue(node, value);
+    }
+    listen(target, eventName, callback, options) {
+        return this.delegate.listen(target, eventName, callback, options);
+    }
+    disableAnimations(element, value) {
+        this.engine.disableAnimations(element, value);
+    }
+}
+class AnimationRenderer extends BaseAnimationRenderer {
+    factory;
+    constructor(factory, namespaceId, delegate, engine, onDestroy) {
+        super(namespaceId, delegate, engine, onDestroy);
+        this.factory = factory;
+        this.namespaceId = namespaceId;
+    }
+    setProperty(el, name, value) {
+        if (name.charAt(0) == ANIMATION_PREFIX) {
+            if (name.charAt(1) == '.' && name == DISABLE_ANIMATIONS_FLAG) {
+                value = value === undefined ? true : !!value;
+                this.disableAnimations(el, value);
+            }
+            else {
+                this.engine.process(this.namespaceId, el, name.slice(1), value);
+            }
+        }
+        else {
+            this.delegate.setProperty(el, name, value);
+        }
+    }
+    listen(target, eventName, callback, options) {
+        if (eventName.charAt(0) == ANIMATION_PREFIX) {
+            const element = resolveElementFromTarget(target);
+            let name = eventName.slice(1);
+            let phase = '';
+            // @listener.phase is for trigger animation callbacks
+            // @@listener is for animation builder callbacks
+            if (name.charAt(0) != ANIMATION_PREFIX) {
+                [name, phase] = parseTriggerCallbackName(name);
+            }
+            return this.engine.listen(this.namespaceId, element, name, phase, (event) => {
+                const countId = event['_data'] || -1;
+                this.factory.scheduleListenerCallback(countId, callback, event);
+            });
+        }
+        return this.delegate.listen(target, eventName, callback, options);
+    }
+}
+function resolveElementFromTarget(target) {
+    switch (target) {
+        case 'body':
+            return document.body;
+        case 'document':
+            return document;
+        case 'window':
+            return window;
+        default:
+            return target;
+    }
+}
+function parseTriggerCallbackName(triggerName) {
+    const dotIndex = triggerName.indexOf('.');
+    const trigger = triggerName.substring(0, dotIndex);
+    const phase = triggerName.slice(dotIndex + 1);
+    return [trigger, phase];
+}
+
+class AnimationRendererFactory {
+    delegate;
+    engine;
+    _zone;
+    _currentId = 0;
+    _microtaskId = 1;
+    _animationCallbacksBuffer = [];
+    _rendererCache = new Map();
+    _cdRecurDepth = 0;
+    constructor(delegate, engine, _zone) {
+        this.delegate = delegate;
+        this.engine = engine;
+        this._zone = _zone;
+        engine.onRemovalComplete = (element, delegate) => {
+            delegate?.removeChild(null, element);
+        };
+    }
+    createRenderer(hostElement, type) {
+        const EMPTY_NAMESPACE_ID = '';
+        // cache the delegates to find out which cached delegate can
+        // be used by which cached renderer
+        const delegate = this.delegate.createRenderer(hostElement, type);
+        if (!hostElement || !type?.data?.['animation']) {
+            const cache = this._rendererCache;
+            let renderer = cache.get(delegate);
+            if (!renderer) {
+                // Ensure that the renderer is removed from the cache on destroy
+                // since it may contain references to detached DOM nodes.
+                const onRendererDestroy = () => cache.delete(delegate);
+                renderer = new BaseAnimationRenderer(EMPTY_NAMESPACE_ID, delegate, this.engine, onRendererDestroy);
+                // only cache this result when the base renderer is used
+                cache.set(delegate, renderer);
+            }
+            return renderer;
+        }
+        const componentId = type.id;
+        const namespaceId = type.id + '-' + this._currentId;
+        this._currentId++;
+        this.engine.register(namespaceId, hostElement);
+        const registerTrigger = (trigger) => {
+            if (Array.isArray(trigger)) {
+                trigger.forEach(registerTrigger);
+            }
+            else {
+                this.engine.registerTrigger(componentId, namespaceId, hostElement, trigger.name, trigger);
+            }
+        };
+        const animationTriggers = type.data['animation'];
+        animationTriggers.forEach(registerTrigger);
+        return new AnimationRenderer(this, namespaceId, delegate, this.engine);
+    }
+    begin() {
+        this._cdRecurDepth++;
+        if (this.delegate.begin) {
+            this.delegate.begin();
+        }
+    }
+    _scheduleCountTask() {
+        queueMicrotask(() => {
+            this._microtaskId++;
+        });
+    }
+    /** @internal */
+    scheduleListenerCallback(count, fn, data) {
+        if (count >= 0 && count < this._microtaskId) {
+            this._zone.run(() => fn(data));
+            return;
+        }
+        const animationCallbacksBuffer = this._animationCallbacksBuffer;
+        if (animationCallbacksBuffer.length == 0) {
+            queueMicrotask(() => {
+                this._zone.run(() => {
+                    animationCallbacksBuffer.forEach((tuple) => {
+                        const [fn, data] = tuple;
+                        fn(data);
+                    });
+                    this._animationCallbacksBuffer = [];
+                });
+            });
+        }
+        animationCallbacksBuffer.push([fn, data]);
+    }
+    end() {
+        this._cdRecurDepth--;
+        // this is to prevent animations from running twice when an inner
+        // component does CD when a parent component instead has inserted it
+        if (this._cdRecurDepth == 0) {
+            this._zone.runOutsideAngular(() => {
+                this._scheduleCountTask();
+                this.engine.flush(this._microtaskId);
+            });
+        }
+        if (this.delegate.end) {
+            this.delegate.end();
+        }
+    }
+    whenRenderingDone() {
+        return this.engine.whenRenderingDone();
+    }
+    /**
+     * Used during HMR to clear any cached data about a component.
+     * @param componentId ID of the component that is being replaced.
+     */
+    componentReplaced(componentId) {
+        // Flush the engine since the renderer destruction waits for animations to be done.
+        this.engine.flush();
+        this.delegate.componentReplaced?.(componentId);
+    }
+}
+
+export { AnimationDriver, NoopAnimationDriver, Animation as ɵAnimation, AnimationEngine as ɵAnimationEngine, AnimationRenderer as ɵAnimationRenderer, AnimationRendererFactory as ɵAnimationRendererFactory, AnimationStyleNormalizer as ɵAnimationStyleNormalizer, BaseAnimationRenderer as ɵBaseAnimationRenderer, ENTER_CLASSNAME as ɵENTER_CLASSNAME, LEAVE_CLASSNAME as ɵLEAVE_CLASSNAME, NoopAnimationStyleNormalizer as ɵNoopAnimationStyleNormalizer, TransitionAnimationPlayer as ɵTransitionAnimationPlayer, WebAnimationsDriver as ɵWebAnimationsDriver, WebAnimationsPlayer as ɵWebAnimationsPlayer, WebAnimationsStyleNormalizer as ɵWebAnimationsStyleNormalizer, allowPreviousPlayerStylesMerge as ɵallowPreviousPlayerStylesMerge, camelCaseToDashCase as ɵcamelCaseToDashCase, containsElement as ɵcontainsElement, createEngine as ɵcreateEngine, getParentElement as ɵgetParentElement, invokeQuery as ɵinvokeQuery, normalizeKeyframes$1 as ɵnormalizeKeyframes, validateStyleProperty as ɵvalidateStyleProperty, validateWebAnimatableStyleProperty as ɵvalidateWebAnimatableStyleProperty };
+//# sourceMappingURL=browser.mjs.map

node_modules/@angular/animations/fesm2022/browser/testing.mjs

@@ -0,0 +1,126 @@
+/**
+ * @license Angular v19.2.13
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import { validateStyleProperty, camelCaseToDashCase, validateWebAnimatableStyleProperty, containsElement, getParentElement, invokeQuery, normalizeKeyframes$1 as normalizeKeyframes, allowPreviousPlayerStylesMerge } from '../util-D9FfmVnv.mjs';
+import { NoopAnimationPlayer, AUTO_STYLE } from '../private_export-faY_wCkZ.mjs';
+import '@angular/core';
+
+/**
+ * @publicApi
+ */
+class MockAnimationDriver {
+    static log = [];
+    validateStyleProperty(prop) {
+        return validateStyleProperty(prop);
+    }
+    validateAnimatableStyleProperty(prop) {
+        const cssProp = camelCaseToDashCase(prop);
+        return validateWebAnimatableStyleProperty(cssProp);
+    }
+    containsElement(elm1, elm2) {
+        return containsElement(elm1, elm2);
+    }
+    getParentElement(element) {
+        return getParentElement(element);
+    }
+    query(element, selector, multi) {
+        return invokeQuery(element, selector, multi);
+    }
+    computeStyle(element, prop, defaultValue) {
+        return defaultValue || '';
+    }
+    animate(element, keyframes, duration, delay, easing, previousPlayers = []) {
+        const player = new MockAnimationPlayer(element, keyframes, duration, delay, easing, previousPlayers);
+        MockAnimationDriver.log.push(player);
+        return player;
+    }
+}
+/**
+ * @publicApi
+ */
+class MockAnimationPlayer extends NoopAnimationPlayer {
+    element;
+    keyframes;
+    duration;
+    delay;
+    easing;
+    previousPlayers;
+    __finished = false;
+    __started = false;
+    previousStyles = new Map();
+    _onInitFns = [];
+    currentSnapshot = new Map();
+    _keyframes = [];
+    constructor(element, keyframes, duration, delay, easing, previousPlayers) {
+        super(duration, delay);
+        this.element = element;
+        this.keyframes = keyframes;
+        this.duration = duration;
+        this.delay = delay;
+        this.easing = easing;
+        this.previousPlayers = previousPlayers;
+        this._keyframes = normalizeKeyframes(keyframes);
+        if (allowPreviousPlayerStylesMerge(duration, delay)) {
+            previousPlayers.forEach((player) => {
+                if (player instanceof MockAnimationPlayer) {
+                    const styles = player.currentSnapshot;
+                    styles.forEach((val, prop) => this.previousStyles.set(prop, val));
+                }
+            });
+        }
+    }
+    /** @internal */
+    onInit(fn) {
+        this._onInitFns.push(fn);
+    }
+    /** @internal */
+    init() {
+        super.init();
+        this._onInitFns.forEach((fn) => fn());
+        this._onInitFns = [];
+    }
+    reset() {
+        super.reset();
+        this.__started = false;
+    }
+    finish() {
+        super.finish();
+        this.__finished = true;
+    }
+    destroy() {
+        super.destroy();
+        this.__finished = true;
+    }
+    /** @internal */
+    triggerMicrotask() { }
+    play() {
+        super.play();
+        this.__started = true;
+    }
+    hasStarted() {
+        return this.__started;
+    }
+    beforeDestroy() {
+        const captures = new Map();
+        this.previousStyles.forEach((val, prop) => captures.set(prop, val));
+        if (this.hasStarted()) {
+            // when assembling the captured styles, it's important that
+            // we build the keyframe styles in the following order:
+            // {other styles within keyframes, ... previousStyles }
+            this._keyframes.forEach((kf) => {
+                for (let [prop, val] of kf) {
+                    if (prop !== 'offset') {
+                        captures.set(prop, this.__finished ? val : AUTO_STYLE);
+                    }
+                }
+            });
+        }
+        this.currentSnapshot = captures;
+    }
+}
+
+export { MockAnimationDriver, MockAnimationPlayer };
+//# sourceMappingURL=testing.mjs.map

node_modules/@angular/animations/fesm2022/private_export-faY_wCkZ.mjs

@@ -0,0 +1,1176 @@
+/**
+ * @license Angular v19.2.13
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+/**
+ * @description Constants for the categories of parameters that can be defined for animations.
+ *
+ * A corresponding function defines a set of parameters for each category, and
+ * collects them into a corresponding `AnimationMetadata` object.
+ *
+ * @publicApi
+ */
+var AnimationMetadataType;
+(function (AnimationMetadataType) {
+    /**
+     * Associates a named animation state with a set of CSS styles.
+     * See [`state()`](api/animations/state)
+     */
+    AnimationMetadataType[AnimationMetadataType["State"] = 0] = "State";
+    /**
+     * Data for a transition from one animation state to another.
+     * See `transition()`
+     */
+    AnimationMetadataType[AnimationMetadataType["Transition"] = 1] = "Transition";
+    /**
+     * Contains a set of animation steps.
+     * See `sequence()`
+     */
+    AnimationMetadataType[AnimationMetadataType["Sequence"] = 2] = "Sequence";
+    /**
+     * Contains a set of animation steps.
+     * See `group()`
+     */
+    AnimationMetadataType[AnimationMetadataType["Group"] = 3] = "Group";
+    /**
+     * Contains an animation step.
+     * See `animate()`
+     */
+    AnimationMetadataType[AnimationMetadataType["Animate"] = 4] = "Animate";
+    /**
+     * Contains a set of animation steps.
+     * See `keyframes()`
+     */
+    AnimationMetadataType[AnimationMetadataType["Keyframes"] = 5] = "Keyframes";
+    /**
+     * Contains a set of CSS property-value pairs into a named style.
+     * See `style()`
+     */
+    AnimationMetadataType[AnimationMetadataType["Style"] = 6] = "Style";
+    /**
+     * Associates an animation with an entry trigger that can be attached to an element.
+     * See `trigger()`
+     */
+    AnimationMetadataType[AnimationMetadataType["Trigger"] = 7] = "Trigger";
+    /**
+     * Contains a re-usable animation.
+     * See `animation()`
+     */
+    AnimationMetadataType[AnimationMetadataType["Reference"] = 8] = "Reference";
+    /**
+     * Contains data to use in executing child animations returned by a query.
+     * See `animateChild()`
+     */
+    AnimationMetadataType[AnimationMetadataType["AnimateChild"] = 9] = "AnimateChild";
+    /**
+     * Contains animation parameters for a re-usable animation.
+     * See `useAnimation()`
+     */
+    AnimationMetadataType[AnimationMetadataType["AnimateRef"] = 10] = "AnimateRef";
+    /**
+     * Contains child-animation query data.
+     * See `query()`
+     */
+    AnimationMetadataType[AnimationMetadataType["Query"] = 11] = "Query";
+    /**
+     * Contains data for staggering an animation sequence.
+     * See `stagger()`
+     */
+    AnimationMetadataType[AnimationMetadataType["Stagger"] = 12] = "Stagger";
+})(AnimationMetadataType || (AnimationMetadataType = {}));
+/**
+ * Specifies automatic styling.
+ *
+ * @publicApi
+ */
+const AUTO_STYLE = '*';
+/**
+ * Creates a named animation trigger, containing a  list of [`state()`](api/animations/state)
+ * and `transition()` entries to be evaluated when the expression
+ * bound to the trigger changes.
+ *
+ * @param name An identifying string.
+ * @param definitions  An animation definition object, containing an array of
+ * [`state()`](api/animations/state) and `transition()` declarations.
+ *
+ * @return An object that encapsulates the trigger data.
+ *
+ * @usageNotes
+ * Define an animation trigger in the `animations` section of `@Component` metadata.
+ * In the template, reference the trigger by name and bind it to a trigger expression that
+ * evaluates to a defined animation state, using the following format:
+ *
+ * `[@triggerName]="expression"`
+ *
+ * Animation trigger bindings convert all values to strings, and then match the
+ * previous and current values against any linked transitions.
+ * Booleans can be specified as `1` or `true` and `0` or `false`.
+ *
+ * ### Usage Example
+ *
+ * The following example creates an animation trigger reference based on the provided
+ * name value.
+ * The provided animation value is expected to be an array consisting of state and
+ * transition declarations.
+ *
+ * ```ts
+ * @Component({
+ *   selector: "my-component",
+ *   templateUrl: "my-component-tpl.html",
+ *   animations: [
+ *     trigger("myAnimationTrigger", [
+ *       state(...),
+ *       state(...),
+ *       transition(...),
+ *       transition(...)
+ *     ])
+ *   ]
+ * })
+ * class MyComponent {
+ *   myStatusExp = "something";
+ * }
+ * ```
+ *
+ * The template associated with this component makes use of the defined trigger
+ * by binding to an element within its template code.
+ *
+ * ```html
+ * <!-- somewhere inside of my-component-tpl.html -->
+ * <div [@myAnimationTrigger]="myStatusExp">...</div>
+ * ```
+ *
+ * ### Using an inline function
+ * The `transition` animation method also supports reading an inline function which can decide
+ * if its associated animation should be run.
+ *
+ * ```ts
+ * // this method is run each time the `myAnimationTrigger` trigger value changes.
+ * function myInlineMatcherFn(fromState: string, toState: string, element: any, params: {[key:
+ string]: any}): boolean {
+ *   // notice that `element` and `params` are also available here
+ *   return toState == 'yes-please-animate';
+ * }
+ *
+ * @Component({
+ *   selector: 'my-component',
+ *   templateUrl: 'my-component-tpl.html',
+ *   animations: [
+ *     trigger('myAnimationTrigger', [
+ *       transition(myInlineMatcherFn, [
+ *         // the animation sequence code
+ *       ]),
+ *     ])
+ *   ]
+ * })
+ * class MyComponent {
+ *   myStatusExp = "yes-please-animate";
+ * }
+ * ```
+ *
+ * ### Disabling Animations
+ * When true, the special animation control binding `@.disabled` binding prevents
+ * all animations from rendering.
+ * Place the  `@.disabled` binding on an element to disable
+ * animations on the element itself, as well as any inner animation triggers
+ * within the element.
+ *
+ * The following example shows how to use this feature:
+ *
+ * ```angular-ts
+ * @Component({
+ *   selector: 'my-component',
+ *   template: `
+ *     <div [@.disabled]="isDisabled">
+ *       <div [@childAnimation]="exp"></div>
+ *     </div>
+ *   `,
+ *   animations: [
+ *     trigger("childAnimation", [
+ *       // ...
+ *     ])
+ *   ]
+ * })
+ * class MyComponent {
+ *   isDisabled = true;
+ *   exp = '...';
+ * }
+ * ```
+ *
+ * When `@.disabled` is true, it prevents the `@childAnimation` trigger from animating,
+ * along with any inner animations.
+ *
+ * ### Disable animations application-wide
+ * When an area of the template is set to have animations disabled,
+ * **all** inner components have their animations disabled as well.
+ * This means that you can disable all animations for an app
+ * by placing a host binding set on `@.disabled` on the topmost Angular component.
+ *
+ * ```ts
+ * import {Component, HostBinding} from '@angular/core';
+ *
+ * @Component({
+ *   selector: 'app-component',
+ *   templateUrl: 'app.component.html',
+ * })
+ * class AppComponent {
+ *   @HostBinding('@.disabled')
+ *   public animationsDisabled = true;
+ * }
+ * ```
+ *
+ * ### Overriding disablement of inner animations
+ * Despite inner animations being disabled, a parent animation can `query()`
+ * for inner elements located in disabled areas of the template and still animate
+ * them if needed. This is also the case for when a sub animation is
+ * queried by a parent and then later animated using `animateChild()`.
+ *
+ * ### Detecting when an animation is disabled
+ * If a region of the DOM (or the entire application) has its animations disabled, the animation
+ * trigger callbacks still fire, but for zero seconds. When the callback fires, it provides
+ * an instance of an `AnimationEvent`. If animations are disabled,
+ * the `.disabled` flag on the event is true.
+ *
+ * @publicApi
+ */
+function trigger(name, definitions) {
+    return { type: AnimationMetadataType.Trigger, name, definitions, options: {} };
+}
+/**
+ * Defines an animation step that combines styling information with timing information.
+ *
+ * @param timings Sets `AnimateTimings` for the parent animation.
+ * A string in the format "duration [delay] [easing]".
+ *  - Duration and delay are expressed as a number and optional time unit,
+ * such as "1s" or "10ms" for one second and 10 milliseconds, respectively.
+ * The default unit is milliseconds.
+ *  - The easing value controls how the animation accelerates and decelerates
+ * during its runtime. Value is one of  `ease`, `ease-in`, `ease-out`,
+ * `ease-in-out`, or a `cubic-bezier()` function call.
+ * If not supplied, no easing is applied.
+ *
+ * For example, the string "1s 100ms ease-out" specifies a duration of
+ * 1000 milliseconds, and delay of 100 ms, and the "ease-out" easing style,
+ * which decelerates near the end of the duration.
+ * @param styles Sets AnimationStyles for the parent animation.
+ * A function call to either `style()` or `keyframes()`
+ * that returns a collection of CSS style entries to be applied to the parent animation.
+ * When null, uses the styles from the destination state.
+ * This is useful when describing an animation step that will complete an animation;
+ * see "Animating to the final state" in `transitions()`.
+ * @returns An object that encapsulates the animation step.
+ *
+ * @usageNotes
+ * Call within an animation `sequence()`, {@link /api/animations/group group()}, or
+ * `transition()` call to specify an animation step
+ * that applies given style data to the parent animation for a given amount of time.
+ *
+ * ### Syntax Examples
+ * **Timing examples**
+ *
+ * The following examples show various `timings` specifications.
+ * - `animate(500)` : Duration is 500 milliseconds.
+ * - `animate("1s")` : Duration is 1000 milliseconds.
+ * - `animate("100ms 0.5s")` : Duration is 100 milliseconds, delay is 500 milliseconds.
+ * - `animate("5s ease-in")` : Duration is 5000 milliseconds, easing in.
+ * - `animate("5s 10ms cubic-bezier(.17,.67,.88,.1)")` : Duration is 5000 milliseconds, delay is 10
+ * milliseconds, easing according to a bezier curve.
+ *
+ * **Style examples**
+ *
+ * The following example calls `style()` to set a single CSS style.
+ * ```ts
+ * animate(500, style({ background: "red" }))
+ * ```
+ * The following example calls `keyframes()` to set a CSS style
+ * to different values for successive keyframes.
+ * ```ts
+ * animate(500, keyframes(
+ *  [
+ *   style({ background: "blue" }),
+ *   style({ background: "red" })
+ *  ])
+ * ```
+ *
+ * @publicApi
+ */
+function animate(timings, styles = null) {
+    return { type: AnimationMetadataType.Animate, styles, timings };
+}
+/**
+ * @description Defines a list of animation steps to be run in parallel.
+ *
+ * @param steps An array of animation step objects.
+ * - When steps are defined by `style()` or `animate()`
+ * function calls, each call within the group is executed instantly.
+ * - To specify offset styles to be applied at a later time, define steps with
+ * `keyframes()`, or use `animate()` calls with a delay value.
+ * For example:
+ *
+ * ```ts
+ * group([
+ *   animate("1s", style({ background: "black" })),
+ *   animate("2s", style({ color: "white" }))
+ * ])
+ * ```
+ *
+ * @param options An options object containing a delay and
+ * developer-defined parameters that provide styling defaults and
+ * can be overridden on invocation.
+ *
+ * @return An object that encapsulates the group data.
+ *
+ * @usageNotes
+ * Grouped animations are useful when a series of styles must be
+ * animated at different starting times and closed off at different ending times.
+ *
+ * When called within a `sequence()` or a
+ * `transition()` call, does not continue to the next
+ * instruction until all of the inner animation steps have completed.
+ *
+ * @publicApi
+ */
+function group(steps, options = null) {
+    return { type: AnimationMetadataType.Group, steps, options };
+}
+/**
+ * Defines a list of animation steps to be run sequentially, one by one.
+ *
+ * @param steps An array of animation step objects.
+ * - Steps defined by `style()` calls apply the styling data immediately.
+ * - Steps defined by `animate()` calls apply the styling data over time
+ *   as specified by the timing data.
+ *
+ * ```ts
+ * sequence([
+ *   style({ opacity: 0 }),
+ *   animate("1s", style({ opacity: 1 }))
+ * ])
+ * ```
+ *
+ * @param options An options object containing a delay and
+ * developer-defined parameters that provide styling defaults and
+ * can be overridden on invocation.
+ *
+ * @return An object that encapsulates the sequence data.
+ *
+ * @usageNotes
+ * When you pass an array of steps to a
+ * `transition()` call, the steps run sequentially by default.
+ * Compare this to the  {@link /api/animations/group group()} call, which runs animation steps in
+ *parallel.
+ *
+ * When a sequence is used within a  {@link /api/animations/group group()} or a `transition()` call,
+ * execution continues to the next instruction only after each of the inner animation
+ * steps have completed.
+ *
+ * @publicApi
+ **/
+function sequence(steps, options = null) {
+    return { type: AnimationMetadataType.Sequence, steps, options };
+}
+/**
+ * Declares a key/value object containing CSS properties/styles that
+ * can then be used for an animation [`state`](api/animations/state), within an animation
+ *`sequence`, or as styling data for calls to `animate()` and `keyframes()`.
+ *
+ * @param tokens A set of CSS styles or HTML styles associated with an animation state.
+ * The value can be any of the following:
+ * - A key-value style pair associating a CSS property with a value.
+ * - An array of key-value style pairs.
+ * - An asterisk (*), to use auto-styling, where styles are derived from the element
+ * being animated and applied to the animation when it starts.
+ *
+ * Auto-styling can be used to define a state that depends on layout or other
+ * environmental factors.
+ *
+ * @return An object that encapsulates the style data.
+ *
+ * @usageNotes
+ * The following examples create animation styles that collect a set of
+ * CSS property values:
+ *
+ * ```ts
+ * // string values for CSS properties
+ * style({ background: "red", color: "blue" })
+ *
+ * // numerical pixel values
+ * style({ width: 100, height: 0 })
+ * ```
+ *
+ * The following example uses auto-styling to allow an element to animate from
+ * a height of 0 up to its full height:
+ *
+ * ```ts
+ * style({ height: 0 }),
+ * animate("1s", style({ height: "*" }))
+ * ```
+ *
+ * @publicApi
+ **/
+function style(tokens) {
+    return { type: AnimationMetadataType.Style, styles: tokens, offset: null };
+}
+/**
+ * Declares an animation state within a trigger attached to an element.
+ *
+ * @param name One or more names for the defined state in a comma-separated string.
+ * The following reserved state names can be supplied to define a style for specific use
+ * cases:
+ *
+ * - `void` You can associate styles with this name to be used when
+ * the element is detached from the application. For example, when an `ngIf` evaluates
+ * to false, the state of the associated element is void.
+ *  - `*` (asterisk) Indicates the default state. You can associate styles with this name
+ * to be used as the fallback when the state that is being animated is not declared
+ * within the trigger.
+ *
+ * @param styles A set of CSS styles associated with this state, created using the
+ * `style()` function.
+ * This set of styles persists on the element once the state has been reached.
+ * @param options Parameters that can be passed to the state when it is invoked.
+ * 0 or more key-value pairs.
+ * @return An object that encapsulates the new state data.
+ *
+ * @usageNotes
+ * Use the `trigger()` function to register states to an animation trigger.
+ * Use the `transition()` function to animate between states.
+ * When a state is active within a component, its associated styles persist on the element,
+ * even when the animation ends.
+ *
+ * @publicApi
+ **/
+function state(name, styles, options) {
+    return { type: AnimationMetadataType.State, name, styles, options };
+}
+/**
+ * Defines a set of animation styles, associating each style with an optional `offset` value.
+ *
+ * @param steps A set of animation styles with optional offset data.
+ * The optional `offset` value for a style specifies a percentage of the total animation
+ * time at which that style is applied.
+ * @returns An object that encapsulates the keyframes data.
+ *
+ * @usageNotes
+ * Use with the `animate()` call. Instead of applying animations
+ * from the current state
+ * to the destination state, keyframes describe how each style entry is applied and at what point
+ * within the animation arc.
+ * Compare [CSS Keyframe Animations](https://www.w3schools.com/css/css3_animations.asp).
+ *
+ * ### Usage
+ *
+ * In the following example, the offset values describe
+ * when each `backgroundColor` value is applied. The color is red at the start, and changes to
+ * blue when 20% of the total time has elapsed.
+ *
+ * ```ts
+ * // the provided offset values
+ * animate("5s", keyframes([
+ *   style({ backgroundColor: "red", offset: 0 }),
+ *   style({ backgroundColor: "blue", offset: 0.2 }),
+ *   style({ backgroundColor: "orange", offset: 0.3 }),
+ *   style({ backgroundColor: "black", offset: 1 })
+ * ]))
+ * ```
+ *
+ * If there are no `offset` values specified in the style entries, the offsets
+ * are calculated automatically.
+ *
+ * ```ts
+ * animate("5s", keyframes([
+ *   style({ backgroundColor: "red" }) // offset = 0
+ *   style({ backgroundColor: "blue" }) // offset = 0.33
+ *   style({ backgroundColor: "orange" }) // offset = 0.66
+ *   style({ backgroundColor: "black" }) // offset = 1
+ * ]))
+ *```
+
+ * @publicApi
+ */
+function keyframes(steps) {
+    return { type: AnimationMetadataType.Keyframes, steps };
+}
+/**
+ * Declares an animation transition which is played when a certain specified condition is met.
+ *
+ * @param stateChangeExpr A string with a specific format or a function that specifies when the
+ * animation transition should occur (see [State Change Expression](#state-change-expression)).
+ *
+ * @param steps One or more animation objects that represent the animation's instructions.
+ *
+ * @param options An options object that can be used to specify a delay for the animation or provide
+ * custom parameters for it.
+ *
+ * @returns An object that encapsulates the transition data.
+ *
+ * @usageNotes
+ *
+ * ### State Change Expression
+ *
+ * The State Change Expression instructs Angular when to run the transition's animations, it can
+ *either be
+ *  - a string with a specific syntax
+ *  - or a function that compares the previous and current state (value of the expression bound to
+ *    the element's trigger) and returns `true` if the transition should occur or `false` otherwise
+ *
+ * The string format can be:
+ *  - `fromState => toState`, which indicates that the transition's animations should occur then the
+ *    expression bound to the trigger's element goes from `fromState` to `toState`
+ *
+ *    _Example:_
+ *      ```ts
+ *        transition('open => closed', animate('.5s ease-out', style({ height: 0 }) ))
+ *      ```
+ *
+ *  - `fromState <=> toState`, which indicates that the transition's animations should occur then
+ *    the expression bound to the trigger's element goes from `fromState` to `toState` or vice versa
+ *
+ *    _Example:_
+ *      ```ts
+ *        transition('enabled <=> disabled', animate('1s cubic-bezier(0.8,0.3,0,1)'))
+ *      ```
+ *
+ *  - `:enter`/`:leave`, which indicates that the transition's animations should occur when the
+ *    element enters or exists the DOM
+ *
+ *    _Example:_
+ *      ```ts
+ *        transition(':enter', [
+ *          style({ opacity: 0 }),
+ *          animate('500ms', style({ opacity: 1 }))
+ *        ])
+ *      ```
+ *
+ *  - `:increment`/`:decrement`, which indicates that the transition's animations should occur when
+ *    the numerical expression bound to the trigger's element has increased in value or decreased
+ *
+ *    _Example:_
+ *      ```ts
+ *        transition(':increment', query('@counter', animateChild()))
+ *      ```
+ *
+ *  - a sequence of any of the above divided by commas, which indicates that transition's animations
+ *    should occur whenever one of the state change expressions matches
+ *
+ *    _Example:_
+ *      ```ts
+ *        transition(':increment, * => enabled, :enter', animate('1s ease', keyframes([
+ *          style({ transform: 'scale(1)', offset: 0}),
+ *          style({ transform: 'scale(1.1)', offset: 0.7}),
+ *          style({ transform: 'scale(1)', offset: 1})
+ *        ]))),
+ *      ```
+ *
+ * Also note that in such context:
+ *  - `void` can be used to indicate the absence of the element
+ *  - asterisks can be used as wildcards that match any state
+ *  - (as a consequence of the above, `void => *` is equivalent to `:enter` and `* => void` is
+ *    equivalent to `:leave`)
+ *  - `true` and `false` also match expression values of `1` and `0` respectively (but do not match
+ *    _truthy_ and _falsy_ values)
+ *
+ * <div class="docs-alert docs-alert-helpful">
+ *
+ *  Be careful about entering end leaving elements as their transitions present a common
+ *  pitfall for developers.
+ *
+ *  Note that when an element with a trigger enters the DOM its `:enter` transition always
+ *  gets executed, but its `:leave` transition will not be executed if the element is removed
+ *  alongside its parent (as it will be removed "without warning" before its transition has
+ *  a chance to be executed, the only way that such transition can occur is if the element
+ *  is exiting the DOM on its own).
+ *
+ *
+ * </div>
+ *
+ * ### Animating to a Final State
+ *
+ * If the final step in a transition is a call to `animate()` that uses a timing value
+ * with no `style` data, that step is automatically considered the final animation arc,
+ * for the element to reach the final state, in such case Angular automatically adds or removes
+ * CSS styles to ensure that the element is in the correct final state.
+ *
+ *
+ * ### Usage Examples
+ *
+ *  - Transition animations applied based on
+ *    the trigger's expression value
+ *
+ *   ```html
+ *   <div [@myAnimationTrigger]="myStatusExp">
+ *    ...
+ *   </div>
+ *   ```
+ *
+ *   ```ts
+ *   trigger("myAnimationTrigger", [
+ *     ..., // states
+ *     transition("on => off, open => closed", animate(500)),
+ *     transition("* <=> error", query('.indicator', animateChild()))
+ *   ])
+ *   ```
+ *
+ *  - Transition animations applied based on custom logic dependent
+ *    on the trigger's expression value and provided parameters
+ *
+ *    ```html
+ *    <div [@myAnimationTrigger]="{
+ *     value: stepName,
+ *     params: { target: currentTarget }
+ *    }">
+ *     ...
+ *    </div>
+ *    ```
+ *
+ *    ```ts
+ *    trigger("myAnimationTrigger", [
+ *      ..., // states
+ *      transition(
+ *        (fromState, toState, _element, params) =>
+ *          ['firststep', 'laststep'].includes(fromState.toLowerCase())
+ *          && toState === params?.['target'],
+ *        animate('1s')
+ *      )
+ *    ])
+ *    ```
+ *
+ * @publicApi
+ **/
+function transition(stateChangeExpr, steps, options = null) {
+    return { type: AnimationMetadataType.Transition, expr: stateChangeExpr, animation: steps, options };
+}
+/**
+ * Produces a reusable animation that can be invoked in another animation or sequence,
+ * by calling the `useAnimation()` function.
+ *
+ * @param steps One or more animation objects, as returned by the `animate()`
+ * or `sequence()` function, that form a transformation from one state to another.
+ * A sequence is used by default when you pass an array.
+ * @param options An options object that can contain a delay value for the start of the
+ * animation, and additional developer-defined parameters.
+ * Provided values for additional parameters are used as defaults,
+ * and override values can be passed to the caller on invocation.
+ * @returns An object that encapsulates the animation data.
+ *
+ * @usageNotes
+ * The following example defines a reusable animation, providing some default parameter
+ * values.
+ *
+ * ```ts
+ * var fadeAnimation = animation([
+ *   style({ opacity: '{{ start }}' }),
+ *   animate('{{ time }}',
+ *   style({ opacity: '{{ end }}'}))
+ *   ],
+ *   { params: { time: '1000ms', start: 0, end: 1 }});
+ * ```
+ *
+ * The following invokes the defined animation with a call to `useAnimation()`,
+ * passing in override parameter values.
+ *
+ * ```js
+ * useAnimation(fadeAnimation, {
+ *   params: {
+ *     time: '2s',
+ *     start: 1,
+ *     end: 0
+ *   }
+ * })
+ * ```
+ *
+ * If any of the passed-in parameter values are missing from this call,
+ * the default values are used. If one or more parameter values are missing before a step is
+ * animated, `useAnimation()` throws an error.
+ *
+ * @publicApi
+ */
+function animation(steps, options = null) {
+    return { type: AnimationMetadataType.Reference, animation: steps, options };
+}
+/**
+ * Executes a queried inner animation element within an animation sequence.
+ *
+ * @param options An options object that can contain a delay value for the start of the
+ * animation, and additional override values for developer-defined parameters.
+ * @return An object that encapsulates the child animation data.
+ *
+ * @usageNotes
+ * Each time an animation is triggered in Angular, the parent animation
+ * has priority and any child animations are blocked. In order
+ * for a child animation to run, the parent animation must query each of the elements
+ * containing child animations, and run them using this function.
+ *
+ * Note that this feature is designed to be used with `query()` and it will only work
+ * with animations that are assigned using the Angular animation library. CSS keyframes
+ * and transitions are not handled by this API.
+ *
+ * @publicApi
+ */
+function animateChild(options = null) {
+    return { type: AnimationMetadataType.AnimateChild, options };
+}
+/**
+ * Starts a reusable animation that is created using the `animation()` function.
+ *
+ * @param animation The reusable animation to start.
+ * @param options An options object that can contain a delay value for the start of
+ * the animation, and additional override values for developer-defined parameters.
+ * @return An object that contains the animation parameters.
+ *
+ * @publicApi
+ */
+function useAnimation(animation, options = null) {
+    return { type: AnimationMetadataType.AnimateRef, animation, options };
+}
+/**
+ * Finds one or more inner elements within the current element that is
+ * being animated within a sequence. Use with `animate()`.
+ *
+ * @param selector The element to query, or a set of elements that contain Angular-specific
+ * characteristics, specified with one or more of the following tokens.
+ *  - `query(":enter")` or `query(":leave")` : Query for newly inserted/removed elements (not
+ *     all elements can be queried via these tokens, see
+ *     [Entering and Leaving Elements](#entering-and-leaving-elements))
+ *  - `query(":animating")` : Query all currently animating elements.
+ *  - `query("@triggerName")` : Query elements that contain an animation trigger.
+ *  - `query("@*")` : Query all elements that contain an animation triggers.
+ *  - `query(":self")` : Include the current element into the animation sequence.
+ *
+ * @param animation One or more animation steps to apply to the queried element or elements.
+ * An array is treated as an animation sequence.
+ * @param options An options object. Use the 'limit' field to limit the total number of
+ * items to collect.
+ * @return An object that encapsulates the query data.
+ *
+ * @usageNotes
+ *
+ * ### Multiple Tokens
+ *
+ * Tokens can be merged into a combined query selector string. For example:
+ *
+ * ```ts
+ *  query(':self, .record:enter, .record:leave, @subTrigger', [...])
+ * ```
+ *
+ * The `query()` function collects multiple elements and works internally by using
+ * `element.querySelectorAll`. Use the `limit` field of an options object to limit
+ * the total number of items to be collected. For example:
+ *
+ * ```js
+ * query('div', [
+ *   animate(...),
+ *   animate(...)
+ * ], { limit: 1 })
+ * ```
+ *
+ * By default, throws an error when zero items are found. Set the
+ * `optional` flag to ignore this error. For example:
+ *
+ * ```js
+ * query('.some-element-that-may-not-be-there', [
+ *   animate(...),
+ *   animate(...)
+ * ], { optional: true })
+ * ```
+ *
+ * ### Entering and Leaving Elements
+ *
+ * Not all elements can be queried via the `:enter` and `:leave` tokens, the only ones
+ * that can are those that Angular assumes can enter/leave based on their own logic
+ * (if their insertion/removal is simply a consequence of that of their parent they
+ * should be queried via a different token in their parent's `:enter`/`:leave` transitions).
+ *
+ * The only elements Angular assumes can enter/leave based on their own logic (thus the only
+ * ones that can be queried via the `:enter` and `:leave` tokens) are:
+ *  - Those inserted dynamically (via `ViewContainerRef`)
+ *  - Those that have a structural directive (which, under the hood, are a subset of the above ones)
+ *
+ * <div class="docs-alert docs-alert-helpful">
+ *
+ *  Note that elements will be successfully queried via `:enter`/`:leave` even if their
+ *  insertion/removal is not done manually via `ViewContainerRef`or caused by their structural
+ *  directive (e.g. they enter/exit alongside their parent).
+ *
+ * </div>
+ *
+ * <div class="docs-alert docs-alert-important">
+ *
+ *  There is an exception to what previously mentioned, besides elements entering/leaving based on
+ *  their own logic, elements with an animation trigger can always be queried via `:leave` when
+ * their parent is also leaving.
+ *
+ * </div>
+ *
+ * ### Usage Example
+ *
+ * The following example queries for inner elements and animates them
+ * individually using `animate()`.
+ *
+ * ```angular-ts
+ * @Component({
+ *   selector: 'inner',
+ *   template: `
+ *     <div [@queryAnimation]="exp">
+ *       <h1>Title</h1>
+ *       <div class="content">
+ *         Blah blah blah
+ *       </div>
+ *     </div>
+ *   `,
+ *   animations: [
+ *    trigger('queryAnimation', [
+ *      transition('* => goAnimate', [
+ *        // hide the inner elements
+ *        query('h1', style({ opacity: 0 })),
+ *        query('.content', style({ opacity: 0 })),
+ *
+ *        // animate the inner elements in, one by one
+ *        query('h1', animate(1000, style({ opacity: 1 }))),
+ *        query('.content', animate(1000, style({ opacity: 1 }))),
+ *      ])
+ *    ])
+ *  ]
+ * })
+ * class Cmp {
+ *   exp = '';
+ *
+ *   goAnimate() {
+ *     this.exp = 'goAnimate';
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+function query(selector, animation, options = null) {
+    return { type: AnimationMetadataType.Query, selector, animation, options };
+}
+/**
+ * Use within an animation `query()` call to issue a timing gap after
+ * each queried item is animated.
+ *
+ * @param timings A delay value.
+ * @param animation One ore more animation steps.
+ * @returns An object that encapsulates the stagger data.
+ *
+ * @usageNotes
+ * In the following example, a container element wraps a list of items stamped out
+ * by an `ngFor`. The container element contains an animation trigger that will later be set
+ * to query for each of the inner items.
+ *
+ * Each time items are added, the opacity fade-in animation runs,
+ * and each removed item is faded out.
+ * When either of these animations occur, the stagger effect is
+ * applied after each item's animation is started.
+ *
+ * ```html
+ * <!-- list.component.html -->
+ * <button (click)="toggle()">Show / Hide Items</button>
+ * <hr />
+ * <div [@listAnimation]="items.length">
+ *   <div *ngFor="let item of items">
+ *     {{ item }}
+ *   </div>
+ * </div>
+ * ```
+ *
+ * Here is the component code:
+ *
+ * ```ts
+ * import {trigger, transition, style, animate, query, stagger} from '@angular/animations';
+ * @Component({
+ *   templateUrl: 'list.component.html',
+ *   animations: [
+ *     trigger('listAnimation', [
+ *     ...
+ *     ])
+ *   ]
+ * })
+ * class ListComponent {
+ *   items = [];
+ *
+ *   showItems() {
+ *     this.items = [0,1,2,3,4];
+ *   }
+ *
+ *   hideItems() {
+ *     this.items = [];
+ *   }
+ *
+ *   toggle() {
+ *     this.items.length ? this.hideItems() : this.showItems();
+ *    }
+ *  }
+ * ```
+ *
+ * Here is the animation trigger code:
+ *
+ * ```ts
+ * trigger('listAnimation', [
+ *   transition('* => *', [ // each time the binding value changes
+ *     query(':leave', [
+ *       stagger(100, [
+ *         animate('0.5s', style({ opacity: 0 }))
+ *       ])
+ *     ]),
+ *     query(':enter', [
+ *       style({ opacity: 0 }),
+ *       stagger(100, [
+ *         animate('0.5s', style({ opacity: 1 }))
+ *       ])
+ *     ])
+ *   ])
+ * ])
+ * ```
+ *
+ * @publicApi
+ */
+function stagger(timings, animation) {
+    return { type: AnimationMetadataType.Stagger, timings, animation };
+}
+
+/**
+ * An empty programmatic controller for reusable animations.
+ * Used internally when animations are disabled, to avoid
+ * checking for the null case when an animation player is expected.
+ *
+ * @see {@link animate}
+ * @see {@link AnimationPlayer}
+ *
+ * @publicApi
+ */
+class NoopAnimationPlayer {
+    _onDoneFns = [];
+    _onStartFns = [];
+    _onDestroyFns = [];
+    _originalOnDoneFns = [];
+    _originalOnStartFns = [];
+    _started = false;
+    _destroyed = false;
+    _finished = false;
+    _position = 0;
+    parentPlayer = null;
+    totalTime;
+    constructor(duration = 0, delay = 0) {
+        this.totalTime = duration + delay;
+    }
+    _onFinish() {
+        if (!this._finished) {
+            this._finished = true;
+            this._onDoneFns.forEach((fn) => fn());
+            this._onDoneFns = [];
+        }
+    }
+    onStart(fn) {
+        this._originalOnStartFns.push(fn);
+        this._onStartFns.push(fn);
+    }
+    onDone(fn) {
+        this._originalOnDoneFns.push(fn);
+        this._onDoneFns.push(fn);
+    }
+    onDestroy(fn) {
+        this._onDestroyFns.push(fn);
+    }
+    hasStarted() {
+        return this._started;
+    }
+    init() { }
+    play() {
+        if (!this.hasStarted()) {
+            this._onStart();
+            this.triggerMicrotask();
+        }
+        this._started = true;
+    }
+    /** @internal */
+    triggerMicrotask() {
+        queueMicrotask(() => this._onFinish());
+    }
+    _onStart() {
+        this._onStartFns.forEach((fn) => fn());
+        this._onStartFns = [];
+    }
+    pause() { }
+    restart() { }
+    finish() {
+        this._onFinish();
+    }
+    destroy() {
+        if (!this._destroyed) {
+            this._destroyed = true;
+            if (!this.hasStarted()) {
+                this._onStart();
+            }
+            this.finish();
+            this._onDestroyFns.forEach((fn) => fn());
+            this._onDestroyFns = [];
+        }
+    }
+    reset() {
+        this._started = false;
+        this._finished = false;
+        this._onStartFns = this._originalOnStartFns;
+        this._onDoneFns = this._originalOnDoneFns;
+    }
+    setPosition(position) {
+        this._position = this.totalTime ? position * this.totalTime : 1;
+    }
+    getPosition() {
+        return this.totalTime ? this._position / this.totalTime : 1;
+    }
+    /** @internal */
+    triggerCallback(phaseName) {
+        const methods = phaseName == 'start' ? this._onStartFns : this._onDoneFns;
+        methods.forEach((fn) => fn());
+        methods.length = 0;
+    }
+}
+
+/**
+ * A programmatic controller for a group of reusable animations.
+ * Used internally to control animations.
+ *
+ * @see {@link AnimationPlayer}
+ * @see {@link animations/group group}
+ *
+ */
+class AnimationGroupPlayer {
+    _onDoneFns = [];
+    _onStartFns = [];
+    _finished = false;
+    _started = false;
+    _destroyed = false;
+    _onDestroyFns = [];
+    parentPlayer = null;
+    totalTime = 0;
+    players;
+    constructor(_players) {
+        this.players = _players;
+        let doneCount = 0;
+        let destroyCount = 0;
+        let startCount = 0;
+        const total = this.players.length;
+        if (total == 0) {
+            queueMicrotask(() => this._onFinish());
+        }
+        else {
+            this.players.forEach((player) => {
+                player.onDone(() => {
+                    if (++doneCount == total) {
+                        this._onFinish();
+                    }
+                });
+                player.onDestroy(() => {
+                    if (++destroyCount == total) {
+                        this._onDestroy();
+                    }
+                });
+                player.onStart(() => {
+                    if (++startCount == total) {
+                        this._onStart();
+                    }
+                });
+            });
+        }
+        this.totalTime = this.players.reduce((time, player) => Math.max(time, player.totalTime), 0);
+    }
+    _onFinish() {
+        if (!this._finished) {
+            this._finished = true;
+            this._onDoneFns.forEach((fn) => fn());
+            this._onDoneFns = [];
+        }
+    }
+    init() {
+        this.players.forEach((player) => player.init());
+    }
+    onStart(fn) {
+        this._onStartFns.push(fn);
+    }
+    _onStart() {
+        if (!this.hasStarted()) {
+            this._started = true;
+            this._onStartFns.forEach((fn) => fn());
+            this._onStartFns = [];
+        }
+    }
+    onDone(fn) {
+        this._onDoneFns.push(fn);
+    }
+    onDestroy(fn) {
+        this._onDestroyFns.push(fn);
+    }
+    hasStarted() {
+        return this._started;
+    }
+    play() {
+        if (!this.parentPlayer) {
+            this.init();
+        }
+        this._onStart();
+        this.players.forEach((player) => player.play());
+    }
+    pause() {
+        this.players.forEach((player) => player.pause());
+    }
+    restart() {
+        this.players.forEach((player) => player.restart());
+    }
+    finish() {
+        this._onFinish();
+        this.players.forEach((player) => player.finish());
+    }
+    destroy() {
+        this._onDestroy();
+    }
+    _onDestroy() {
+        if (!this._destroyed) {
+            this._destroyed = true;
+            this._onFinish();
+            this.players.forEach((player) => player.destroy());
+            this._onDestroyFns.forEach((fn) => fn());
+            this._onDestroyFns = [];
+        }
+    }
+    reset() {
+        this.players.forEach((player) => player.reset());
+        this._destroyed = false;
+        this._finished = false;
+        this._started = false;
+    }
+    setPosition(p) {
+        const timeAtPosition = p * this.totalTime;
+        this.players.forEach((player) => {
+            const position = player.totalTime ? Math.min(1, timeAtPosition / player.totalTime) : 1;
+            player.setPosition(position);
+        });
+    }
+    getPosition() {
+        const longestPlayer = this.players.reduce((longestSoFar, player) => {
+            const newPlayerIsLongest = longestSoFar === null || player.totalTime > longestSoFar.totalTime;
+            return newPlayerIsLongest ? player : longestSoFar;
+        }, null);
+        return longestPlayer != null ? longestPlayer.getPosition() : 0;
+    }
+    beforeDestroy() {
+        this.players.forEach((player) => {
+            if (player.beforeDestroy) {
+                player.beforeDestroy();
+            }
+        });
+    }
+    /** @internal */
+    triggerCallback(phaseName) {
+        const methods = phaseName == 'start' ? this._onStartFns : this._onDoneFns;
+        methods.forEach((fn) => fn());
+        methods.length = 0;
+    }
+}
+
+const ɵPRE_STYLE = '!';
+
+export { AUTO_STYLE, AnimationGroupPlayer, AnimationMetadataType, NoopAnimationPlayer, animate, animateChild, animation, group, keyframes, query, sequence, stagger, state, style, transition, trigger, useAnimation, ɵPRE_STYLE };
+//# sourceMappingURL=private_export-faY_wCkZ.mjs.map

node_modules/@angular/animations/fesm2022/util-D9FfmVnv.mjs

@@ -0,0 +1,697 @@
+/**
+ * @license Angular v19.2.13
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import { AnimationGroupPlayer, NoopAnimationPlayer, AUTO_STYLE, ɵPRE_STYLE as _PRE_STYLE, AnimationMetadataType, sequence } from './private_export-faY_wCkZ.mjs';
+import { ɵRuntimeError as _RuntimeError } from '@angular/core';
+
+const LINE_START = '\n - ';
+function invalidTimingValue(exp) {
+    return new _RuntimeError(3000 /* RuntimeErrorCode.INVALID_TIMING_VALUE */, ngDevMode && `The provided timing value "${exp}" is invalid.`);
+}
+function negativeStepValue() {
+    return new _RuntimeError(3100 /* RuntimeErrorCode.NEGATIVE_STEP_VALUE */, ngDevMode && 'Duration values below 0 are not allowed for this animation step.');
+}
+function negativeDelayValue() {
+    return new _RuntimeError(3101 /* RuntimeErrorCode.NEGATIVE_DELAY_VALUE */, ngDevMode && 'Delay values below 0 are not allowed for this animation step.');
+}
+function invalidStyleParams(varName) {
+    return new _RuntimeError(3001 /* RuntimeErrorCode.INVALID_STYLE_PARAMS */, ngDevMode &&
+        `Unable to resolve the local animation param ${varName} in the given list of values`);
+}
+function invalidParamValue(varName) {
+    return new _RuntimeError(3003 /* RuntimeErrorCode.INVALID_PARAM_VALUE */, ngDevMode && `Please provide a value for the animation param ${varName}`);
+}
+function invalidNodeType(nodeType) {
+    return new _RuntimeError(3004 /* RuntimeErrorCode.INVALID_NODE_TYPE */, ngDevMode && `Unable to resolve animation metadata node #${nodeType}`);
+}
+function invalidCssUnitValue(userProvidedProperty, value) {
+    return new _RuntimeError(3005 /* RuntimeErrorCode.INVALID_CSS_UNIT_VALUE */, ngDevMode && `Please provide a CSS unit value for ${userProvidedProperty}:${value}`);
+}
+function invalidTrigger() {
+    return new _RuntimeError(3006 /* RuntimeErrorCode.INVALID_TRIGGER */, ngDevMode &&
+        "animation triggers cannot be prefixed with an `@` sign (e.g. trigger('@foo', [...]))");
+}
+function invalidDefinition() {
+    return new _RuntimeError(3007 /* RuntimeErrorCode.INVALID_DEFINITION */, ngDevMode && 'only state() and transition() definitions can sit inside of a trigger()');
+}
+function invalidState(metadataName, missingSubs) {
+    return new _RuntimeError(3008 /* RuntimeErrorCode.INVALID_STATE */, ngDevMode &&
+        `state("${metadataName}", ...) must define default values for all the following style substitutions: ${missingSubs.join(', ')}`);
+}
+function invalidStyleValue(value) {
+    return new _RuntimeError(3002 /* RuntimeErrorCode.INVALID_STYLE_VALUE */, ngDevMode && `The provided style string value ${value} is not allowed.`);
+}
+function invalidParallelAnimation(prop, firstStart, firstEnd, secondStart, secondEnd) {
+    return new _RuntimeError(3010 /* RuntimeErrorCode.INVALID_PARALLEL_ANIMATION */, ngDevMode &&
+        `The CSS property "${prop}" that exists between the times of "${firstStart}ms" and "${firstEnd}ms" is also being animated in a parallel animation between the times of "${secondStart}ms" and "${secondEnd}ms"`);
+}
+function invalidKeyframes() {
+    return new _RuntimeError(3011 /* RuntimeErrorCode.INVALID_KEYFRAMES */, ngDevMode && `keyframes() must be placed inside of a call to animate()`);
+}
+function invalidOffset() {
+    return new _RuntimeError(3012 /* RuntimeErrorCode.INVALID_OFFSET */, ngDevMode && `Please ensure that all keyframe offsets are between 0 and 1`);
+}
+function keyframeOffsetsOutOfOrder() {
+    return new _RuntimeError(3200 /* RuntimeErrorCode.KEYFRAME_OFFSETS_OUT_OF_ORDER */, ngDevMode && `Please ensure that all keyframe offsets are in order`);
+}
+function keyframesMissingOffsets() {
+    return new _RuntimeError(3202 /* RuntimeErrorCode.KEYFRAMES_MISSING_OFFSETS */, ngDevMode && `Not all style() steps within the declared keyframes() contain offsets`);
+}
+function invalidStagger() {
+    return new _RuntimeError(3013 /* RuntimeErrorCode.INVALID_STAGGER */, ngDevMode && `stagger() can only be used inside of query()`);
+}
+function invalidQuery(selector) {
+    return new _RuntimeError(3014 /* RuntimeErrorCode.INVALID_QUERY */, ngDevMode &&
+        `\`query("${selector}")\` returned zero elements. (Use \`query("${selector}", { optional: true })\` if you wish to allow this.)`);
+}
+function invalidExpression(expr) {
+    return new _RuntimeError(3015 /* RuntimeErrorCode.INVALID_EXPRESSION */, ngDevMode && `The provided transition expression "${expr}" is not supported`);
+}
+function invalidTransitionAlias(alias) {
+    return new _RuntimeError(3016 /* RuntimeErrorCode.INVALID_TRANSITION_ALIAS */, ngDevMode && `The transition alias value "${alias}" is not supported`);
+}
+function validationFailed(errors) {
+    return new _RuntimeError(3500 /* RuntimeErrorCode.VALIDATION_FAILED */, ngDevMode && `animation validation failed:\n${errors.map((err) => err.message).join('\n')}`);
+}
+function buildingFailed(errors) {
+    return new _RuntimeError(3501 /* RuntimeErrorCode.BUILDING_FAILED */, ngDevMode && `animation building failed:\n${errors.map((err) => err.message).join('\n')}`);
+}
+function triggerBuildFailed(name, errors) {
+    return new _RuntimeError(3404 /* RuntimeErrorCode.TRIGGER_BUILD_FAILED */, ngDevMode &&
+        `The animation trigger "${name}" has failed to build due to the following errors:\n - ${errors
+            .map((err) => err.message)
+            .join('\n - ')}`);
+}
+function animationFailed(errors) {
+    return new _RuntimeError(3502 /* RuntimeErrorCode.ANIMATION_FAILED */, ngDevMode &&
+        `Unable to animate due to the following errors:${LINE_START}${errors
+            .map((err) => err.message)
+            .join(LINE_START)}`);
+}
+function registerFailed(errors) {
+    return new _RuntimeError(3503 /* RuntimeErrorCode.REGISTRATION_FAILED */, ngDevMode &&
+        `Unable to build the animation due to the following errors: ${errors
+            .map((err) => err.message)
+            .join('\n')}`);
+}
+function missingOrDestroyedAnimation() {
+    return new _RuntimeError(3300 /* RuntimeErrorCode.MISSING_OR_DESTROYED_ANIMATION */, ngDevMode && "The requested animation doesn't exist or has already been destroyed");
+}
+function createAnimationFailed(errors) {
+    return new _RuntimeError(3504 /* RuntimeErrorCode.CREATE_ANIMATION_FAILED */, ngDevMode &&
+        `Unable to create the animation due to the following errors:${errors
+            .map((err) => err.message)
+            .join('\n')}`);
+}
+function missingPlayer(id) {
+    return new _RuntimeError(3301 /* RuntimeErrorCode.MISSING_PLAYER */, ngDevMode && `Unable to find the timeline player referenced by ${id}`);
+}
+function missingTrigger(phase, name) {
+    return new _RuntimeError(3302 /* RuntimeErrorCode.MISSING_TRIGGER */, ngDevMode &&
+        `Unable to listen on the animation trigger event "${phase}" because the animation trigger "${name}" doesn\'t exist!`);
+}
+function missingEvent(name) {
+    return new _RuntimeError(3303 /* RuntimeErrorCode.MISSING_EVENT */, ngDevMode &&
+        `Unable to listen on the animation trigger "${name}" because the provided event is undefined!`);
+}
+function unsupportedTriggerEvent(phase, name) {
+    return new _RuntimeError(3400 /* RuntimeErrorCode.UNSUPPORTED_TRIGGER_EVENT */, ngDevMode &&
+        `The provided animation trigger event "${phase}" for the animation trigger "${name}" is not supported!`);
+}
+function unregisteredTrigger(name) {
+    return new _RuntimeError(3401 /* RuntimeErrorCode.UNREGISTERED_TRIGGER */, ngDevMode && `The provided animation trigger "${name}" has not been registered!`);
+}
+function triggerTransitionsFailed(errors) {
+    return new _RuntimeError(3402 /* RuntimeErrorCode.TRIGGER_TRANSITIONS_FAILED */, ngDevMode &&
+        `Unable to process animations due to the following failed trigger transitions\n ${errors
+            .map((err) => err.message)
+            .join('\n')}`);
+}
+function transitionFailed(name, errors) {
+    return new _RuntimeError(3505 /* RuntimeErrorCode.TRANSITION_FAILED */, ngDevMode && `@${name} has failed due to:\n ${errors.map((err) => err.message).join('\n- ')}`);
+}
+
+/**
+ * Set of all animatable CSS properties
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_animated_properties
+ */
+const ANIMATABLE_PROP_SET = new Set([
+    '-moz-outline-radius',
+    '-moz-outline-radius-bottomleft',
+    '-moz-outline-radius-bottomright',
+    '-moz-outline-radius-topleft',
+    '-moz-outline-radius-topright',
+    '-ms-grid-columns',
+    '-ms-grid-rows',
+    '-webkit-line-clamp',
+    '-webkit-text-fill-color',
+    '-webkit-text-stroke',
+    '-webkit-text-stroke-color',
+    'accent-color',
+    'all',
+    'backdrop-filter',
+    'background',
+    'background-color',
+    'background-position',
+    'background-size',
+    'block-size',
+    'border',
+    'border-block-end',
+    'border-block-end-color',
+    'border-block-end-width',
+    'border-block-start',
+    'border-block-start-color',
+    'border-block-start-width',
+    'border-bottom',
+    'border-bottom-color',
+    'border-bottom-left-radius',
+    'border-bottom-right-radius',
+    'border-bottom-width',
+    'border-color',
+    'border-end-end-radius',
+    'border-end-start-radius',
+    'border-image-outset',
+    'border-image-slice',
+    'border-image-width',
+    'border-inline-end',
+    'border-inline-end-color',
+    'border-inline-end-width',
+    'border-inline-start',
+    'border-inline-start-color',
+    'border-inline-start-width',
+    'border-left',
+    'border-left-color',
+    'border-left-width',
+    'border-radius',
+    'border-right',
+    'border-right-color',
+    'border-right-width',
+    'border-start-end-radius',
+    'border-start-start-radius',
+    'border-top',
+    'border-top-color',
+    'border-top-left-radius',
+    'border-top-right-radius',
+    'border-top-width',
+    'border-width',
+    'bottom',
+    'box-shadow',
+    'caret-color',
+    'clip',
+    'clip-path',
+    'color',
+    'column-count',
+    'column-gap',
+    'column-rule',
+    'column-rule-color',
+    'column-rule-width',
+    'column-width',
+    'columns',
+    'filter',
+    'flex',
+    'flex-basis',
+    'flex-grow',
+    'flex-shrink',
+    'font',
+    'font-size',
+    'font-size-adjust',
+    'font-stretch',
+    'font-variation-settings',
+    'font-weight',
+    'gap',
+    'grid-column-gap',
+    'grid-gap',
+    'grid-row-gap',
+    'grid-template-columns',
+    'grid-template-rows',
+    'height',
+    'inline-size',
+    'input-security',
+    'inset',
+    'inset-block',
+    'inset-block-end',
+    'inset-block-start',
+    'inset-inline',
+    'inset-inline-end',
+    'inset-inline-start',
+    'left',
+    'letter-spacing',
+    'line-clamp',
+    'line-height',
+    'margin',
+    'margin-block-end',
+    'margin-block-start',
+    'margin-bottom',
+    'margin-inline-end',
+    'margin-inline-start',
+    'margin-left',
+    'margin-right',
+    'margin-top',
+    'mask',
+    'mask-border',
+    'mask-position',
+    'mask-size',
+    'max-block-size',
+    'max-height',
+    'max-inline-size',
+    'max-lines',
+    'max-width',
+    'min-block-size',
+    'min-height',
+    'min-inline-size',
+    'min-width',
+    'object-position',
+    'offset',
+    'offset-anchor',
+    'offset-distance',
+    'offset-path',
+    'offset-position',
+    'offset-rotate',
+    'opacity',
+    'order',
+    'outline',
+    'outline-color',
+    'outline-offset',
+    'outline-width',
+    'padding',
+    'padding-block-end',
+    'padding-block-start',
+    'padding-bottom',
+    'padding-inline-end',
+    'padding-inline-start',
+    'padding-left',
+    'padding-right',
+    'padding-top',
+    'perspective',
+    'perspective-origin',
+    'right',
+    'rotate',
+    'row-gap',
+    'scale',
+    'scroll-margin',
+    'scroll-margin-block',
+    'scroll-margin-block-end',
+    'scroll-margin-block-start',
+    'scroll-margin-bottom',
+    'scroll-margin-inline',
+    'scroll-margin-inline-end',
+    'scroll-margin-inline-start',
+    'scroll-margin-left',
+    'scroll-margin-right',
+    'scroll-margin-top',
+    'scroll-padding',
+    'scroll-padding-block',
+    'scroll-padding-block-end',
+    'scroll-padding-block-start',
+    'scroll-padding-bottom',
+    'scroll-padding-inline',
+    'scroll-padding-inline-end',
+    'scroll-padding-inline-start',
+    'scroll-padding-left',
+    'scroll-padding-right',
+    'scroll-padding-top',
+    'scroll-snap-coordinate',
+    'scroll-snap-destination',
+    'scrollbar-color',
+    'shape-image-threshold',
+    'shape-margin',
+    'shape-outside',
+    'tab-size',
+    'text-decoration',
+    'text-decoration-color',
+    'text-decoration-thickness',
+    'text-emphasis',
+    'text-emphasis-color',
+    'text-indent',
+    'text-shadow',
+    'text-underline-offset',
+    'top',
+    'transform',
+    'transform-origin',
+    'translate',
+    'vertical-align',
+    'visibility',
+    'width',
+    'word-spacing',
+    'z-index',
+    'zoom',
+]);
+
+function optimizeGroupPlayer(players) {
+    switch (players.length) {
+        case 0:
+            return new NoopAnimationPlayer();
+        case 1:
+            return players[0];
+        default:
+            return new AnimationGroupPlayer(players);
+    }
+}
+function normalizeKeyframes$1(normalizer, keyframes, preStyles = new Map(), postStyles = new Map()) {
+    const errors = [];
+    const normalizedKeyframes = [];
+    let previousOffset = -1;
+    let previousKeyframe = null;
+    keyframes.forEach((kf) => {
+        const offset = kf.get('offset');
+        const isSameOffset = offset == previousOffset;
+        const normalizedKeyframe = (isSameOffset && previousKeyframe) || new Map();
+        kf.forEach((val, prop) => {
+            let normalizedProp = prop;
+            let normalizedValue = val;
+            if (prop !== 'offset') {
+                normalizedProp = normalizer.normalizePropertyName(normalizedProp, errors);
+                switch (normalizedValue) {
+                    case _PRE_STYLE:
+                        normalizedValue = preStyles.get(prop);
+                        break;
+                    case AUTO_STYLE:
+                        normalizedValue = postStyles.get(prop);
+                        break;
+                    default:
+                        normalizedValue = normalizer.normalizeStyleValue(prop, normalizedProp, normalizedValue, errors);
+                        break;
+                }
+            }
+            normalizedKeyframe.set(normalizedProp, normalizedValue);
+        });
+        if (!isSameOffset) {
+            normalizedKeyframes.push(normalizedKeyframe);
+        }
+        previousKeyframe = normalizedKeyframe;
+        previousOffset = offset;
+    });
+    if (errors.length) {
+        throw animationFailed(errors);
+    }
+    return normalizedKeyframes;
+}
+function listenOnPlayer(player, eventName, event, callback) {
+    switch (eventName) {
+        case 'start':
+            player.onStart(() => callback(event && copyAnimationEvent(event, 'start', player)));
+            break;
+        case 'done':
+            player.onDone(() => callback(event && copyAnimationEvent(event, 'done', player)));
+            break;
+        case 'destroy':
+            player.onDestroy(() => callback(event && copyAnimationEvent(event, 'destroy', player)));
+            break;
+    }
+}
+function copyAnimationEvent(e, phaseName, player) {
+    const totalTime = player.totalTime;
+    const disabled = player.disabled ? true : false;
+    const event = makeAnimationEvent(e.element, e.triggerName, e.fromState, e.toState, phaseName || e.phaseName, totalTime == undefined ? e.totalTime : totalTime, disabled);
+    const data = e['_data'];
+    if (data != null) {
+        event['_data'] = data;
+    }
+    return event;
+}
+function makeAnimationEvent(element, triggerName, fromState, toState, phaseName = '', totalTime = 0, disabled) {
+    return { element, triggerName, fromState, toState, phaseName, totalTime, disabled: !!disabled };
+}
+function getOrSetDefaultValue(map, key, defaultValue) {
+    let value = map.get(key);
+    if (!value) {
+        map.set(key, (value = defaultValue));
+    }
+    return value;
+}
+function parseTimelineCommand(command) {
+    const separatorPos = command.indexOf(':');
+    const id = command.substring(1, separatorPos);
+    const action = command.slice(separatorPos + 1);
+    return [id, action];
+}
+const documentElement = /* @__PURE__ */ (() => typeof document === 'undefined' ? null : document.documentElement)();
+function getParentElement(element) {
+    const parent = element.parentNode || element.host || null; // consider host to support shadow DOM
+    if (parent === documentElement) {
+        return null;
+    }
+    return parent;
+}
+function containsVendorPrefix(prop) {
+    // Webkit is the only real popular vendor prefix nowadays
+    // cc: http://shouldiprefix.com/
+    return prop.substring(1, 6) == 'ebkit'; // webkit or Webkit
+}
+let _CACHED_BODY = null;
+let _IS_WEBKIT = false;
+function validateStyleProperty(prop) {
+    if (!_CACHED_BODY) {
+        _CACHED_BODY = getBodyNode() || {};
+        _IS_WEBKIT = _CACHED_BODY.style ? 'WebkitAppearance' in _CACHED_BODY.style : false;
+    }
+    let result = true;
+    if (_CACHED_BODY.style && !containsVendorPrefix(prop)) {
+        result = prop in _CACHED_BODY.style;
+        if (!result && _IS_WEBKIT) {
+            const camelProp = 'Webkit' + prop.charAt(0).toUpperCase() + prop.slice(1);
+            result = camelProp in _CACHED_BODY.style;
+        }
+    }
+    return result;
+}
+function validateWebAnimatableStyleProperty(prop) {
+    return ANIMATABLE_PROP_SET.has(prop);
+}
+function getBodyNode() {
+    if (typeof document != 'undefined') {
+        return document.body;
+    }
+    return null;
+}
+function containsElement(elm1, elm2) {
+    while (elm2) {
+        if (elm2 === elm1) {
+            return true;
+        }
+        elm2 = getParentElement(elm2);
+    }
+    return false;
+}
+function invokeQuery(element, selector, multi) {
+    if (multi) {
+        return Array.from(element.querySelectorAll(selector));
+    }
+    const elem = element.querySelector(selector);
+    return elem ? [elem] : [];
+}
+
+const ONE_SECOND = 1000;
+const SUBSTITUTION_EXPR_START = '{{';
+const SUBSTITUTION_EXPR_END = '}}';
+const ENTER_CLASSNAME = 'ng-enter';
+const LEAVE_CLASSNAME = 'ng-leave';
+const NG_TRIGGER_CLASSNAME = 'ng-trigger';
+const NG_TRIGGER_SELECTOR = '.ng-trigger';
+const NG_ANIMATING_CLASSNAME = 'ng-animating';
+const NG_ANIMATING_SELECTOR = '.ng-animating';
+function resolveTimingValue(value) {
+    if (typeof value == 'number')
+        return value;
+    const matches = value.match(/^(-?[\.\d]+)(m?s)/);
+    if (!matches || matches.length < 2)
+        return 0;
+    return _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);
+}
+function _convertTimeValueToMS(value, unit) {
+    switch (unit) {
+        case 's':
+            return value * ONE_SECOND;
+        default: // ms or something else
+            return value;
+    }
+}
+function resolveTiming(timings, errors, allowNegativeValues) {
+    return timings.hasOwnProperty('duration')
+        ? timings
+        : parseTimeExpression(timings, errors, allowNegativeValues);
+}
+function parseTimeExpression(exp, errors, allowNegativeValues) {
+    const regex = /^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i;
+    let duration;
+    let delay = 0;
+    let easing = '';
+    if (typeof exp === 'string') {
+        const matches = exp.match(regex);
+        if (matches === null) {
+            errors.push(invalidTimingValue(exp));
+            return { duration: 0, delay: 0, easing: '' };
+        }
+        duration = _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);
+        const delayMatch = matches[3];
+        if (delayMatch != null) {
+            delay = _convertTimeValueToMS(parseFloat(delayMatch), matches[4]);
+        }
+        const easingVal = matches[5];
+        if (easingVal) {
+            easing = easingVal;
+        }
+    }
+    else {
+        duration = exp;
+    }
+    if (!allowNegativeValues) {
+        let containsErrors = false;
+        let startIndex = errors.length;
+        if (duration < 0) {
+            errors.push(negativeStepValue());
+            containsErrors = true;
+        }
+        if (delay < 0) {
+            errors.push(negativeDelayValue());
+            containsErrors = true;
+        }
+        if (containsErrors) {
+            errors.splice(startIndex, 0, invalidTimingValue(exp));
+        }
+    }
+    return { duration, delay, easing };
+}
+function normalizeKeyframes(keyframes) {
+    if (!keyframes.length) {
+        return [];
+    }
+    if (keyframes[0] instanceof Map) {
+        return keyframes;
+    }
+    return keyframes.map((kf) => new Map(Object.entries(kf)));
+}
+function normalizeStyles(styles) {
+    return Array.isArray(styles) ? new Map(...styles) : new Map(styles);
+}
+function setStyles(element, styles, formerStyles) {
+    styles.forEach((val, prop) => {
+        const camelProp = dashCaseToCamelCase(prop);
+        if (formerStyles && !formerStyles.has(prop)) {
+            formerStyles.set(prop, element.style[camelProp]);
+        }
+        element.style[camelProp] = val;
+    });
+}
+function eraseStyles(element, styles) {
+    styles.forEach((_, prop) => {
+        const camelProp = dashCaseToCamelCase(prop);
+        element.style[camelProp] = '';
+    });
+}
+function normalizeAnimationEntry(steps) {
+    if (Array.isArray(steps)) {
+        if (steps.length == 1)
+            return steps[0];
+        return sequence(steps);
+    }
+    return steps;
+}
+function validateStyleParams(value, options, errors) {
+    const params = options.params || {};
+    const matches = extractStyleParams(value);
+    if (matches.length) {
+        matches.forEach((varName) => {
+            if (!params.hasOwnProperty(varName)) {
+                errors.push(invalidStyleParams(varName));
+            }
+        });
+    }
+}
+const PARAM_REGEX = /* @__PURE__ */ new RegExp(`${SUBSTITUTION_EXPR_START}\\s*(.+?)\\s*${SUBSTITUTION_EXPR_END}`, 'g');
+function extractStyleParams(value) {
+    let params = [];
+    if (typeof value === 'string') {
+        let match;
+        while ((match = PARAM_REGEX.exec(value))) {
+            params.push(match[1]);
+        }
+        PARAM_REGEX.lastIndex = 0;
+    }
+    return params;
+}
+function interpolateParams(value, params, errors) {
+    const original = `${value}`;
+    const str = original.replace(PARAM_REGEX, (_, varName) => {
+        let localVal = params[varName];
+        // this means that the value was never overridden by the data passed in by the user
+        if (localVal == null) {
+            errors.push(invalidParamValue(varName));
+            localVal = '';
+        }
+        return localVal.toString();
+    });
+    // we do this to assert that numeric values stay as they are
+    return str == original ? value : str;
+}
+const DASH_CASE_REGEXP = /-+([a-z0-9])/g;
+function dashCaseToCamelCase(input) {
+    return input.replace(DASH_CASE_REGEXP, (...m) => m[1].toUpperCase());
+}
+function camelCaseToDashCase(input) {
+    return input.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+function allowPreviousPlayerStylesMerge(duration, delay) {
+    return duration === 0 || delay === 0;
+}
+function balancePreviousStylesIntoKeyframes(element, keyframes, previousStyles) {
+    if (previousStyles.size && keyframes.length) {
+        let startingKeyframe = keyframes[0];
+        let missingStyleProps = [];
+        previousStyles.forEach((val, prop) => {
+            if (!startingKeyframe.has(prop)) {
+                missingStyleProps.push(prop);
+            }
+            startingKeyframe.set(prop, val);
+        });
+        if (missingStyleProps.length) {
+            for (let i = 1; i < keyframes.length; i++) {
+                let kf = keyframes[i];
+                missingStyleProps.forEach((prop) => kf.set(prop, computeStyle(element, prop)));
+            }
+        }
+    }
+    return keyframes;
+}
+function visitDslNode(visitor, node, context) {
+    switch (node.type) {
+        case AnimationMetadataType.Trigger:
+            return visitor.visitTrigger(node, context);
+        case AnimationMetadataType.State:
+            return visitor.visitState(node, context);
+        case AnimationMetadataType.Transition:
+            return visitor.visitTransition(node, context);
+        case AnimationMetadataType.Sequence:
+            return visitor.visitSequence(node, context);
+        case AnimationMetadataType.Group:
+            return visitor.visitGroup(node, context);
+        case AnimationMetadataType.Animate:
+            return visitor.visitAnimate(node, context);
+        case AnimationMetadataType.Keyframes:
+            return visitor.visitKeyframes(node, context);
+        case AnimationMetadataType.Style:
+            return visitor.visitStyle(node, context);
+        case AnimationMetadataType.Reference:
+            return visitor.visitReference(node, context);
+        case AnimationMetadataType.AnimateChild:
+            return visitor.visitAnimateChild(node, context);
+        case AnimationMetadataType.AnimateRef:
+            return visitor.visitAnimateRef(node, context);
+        case AnimationMetadataType.Query:
+            return visitor.visitQuery(node, context);
+        case AnimationMetadataType.Stagger:
+            return visitor.visitStagger(node, context);
+        default:
+            throw invalidNodeType(node.type);
+    }
+}
+function computeStyle(element, prop) {
+    return window.getComputedStyle(element)[prop];
+}
+
+export { ENTER_CLASSNAME, LEAVE_CLASSNAME, NG_ANIMATING_CLASSNAME, NG_ANIMATING_SELECTOR, NG_TRIGGER_CLASSNAME, NG_TRIGGER_SELECTOR, SUBSTITUTION_EXPR_START, allowPreviousPlayerStylesMerge, balancePreviousStylesIntoKeyframes, buildingFailed, camelCaseToDashCase, computeStyle, containsElement, createAnimationFailed, dashCaseToCamelCase, eraseStyles, extractStyleParams, getOrSetDefaultValue, getParentElement, interpolateParams, invalidCssUnitValue, invalidDefinition, invalidExpression, invalidKeyframes, invalidOffset, invalidParallelAnimation, invalidQuery, invalidStagger, invalidState, invalidStyleValue, invalidTransitionAlias, invalidTrigger, invokeQuery, keyframeOffsetsOutOfOrder, keyframesMissingOffsets, listenOnPlayer, makeAnimationEvent, missingEvent, missingOrDestroyedAnimation, missingPlayer, missingTrigger, normalizeAnimationEntry, normalizeKeyframes$1 as normalizeKeyframes, normalizeKeyframes as normalizeKeyframes$1, normalizeStyles, optimizeGroupPlayer, parseTimelineCommand, registerFailed, resolveTiming, resolveTimingValue, setStyles, transitionFailed, triggerBuildFailed, triggerTransitionsFailed, unregisteredTrigger, unsupportedTriggerEvent, validateStyleParams, validateStyleProperty, validateWebAnimatableStyleProperty, validationFailed, visitDslNode };
+//# sourceMappingURL=util-D9FfmVnv.mjs.map

node_modules/@angular/animations/index.d.ts

@@ -0,0 +1,246 @@
+/**
+ * @license Angular v19.2.13
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import * as i0 from '@angular/core';
+import { RendererFactory2 } from '@angular/core';
+import { AnimationMetadata, AnimationOptions, AnimationPlayer } from './animation_player.d-Dv9iW4uh.js';
+export { AUTO_STYLE, AnimateChildOptions, AnimateTimings, AnimationAnimateChildMetadata, AnimationAnimateMetadata, AnimationAnimateRefMetadata, AnimationGroupMetadata, AnimationKeyframesSequenceMetadata, AnimationMetadataType, AnimationQueryMetadata, AnimationQueryOptions, AnimationReferenceMetadata, AnimationSequenceMetadata, AnimationStaggerMetadata, AnimationStateMetadata, AnimationStyleMetadata, AnimationTransitionMetadata, AnimationTriggerMetadata, NoopAnimationPlayer, animate, animateChild, animation, group, keyframes, query, sequence, stagger, state, style, transition, trigger, useAnimation, ɵStyleData, ɵStyleDataMap } from './animation_player.d-Dv9iW4uh.js';
+
+/**
+ * An injectable service that produces an animation sequence programmatically within an
+ * Angular component or directive.
+ * Provided by the `BrowserAnimationsModule` or `NoopAnimationsModule`.
+ *
+ * @usageNotes
+ *
+ * To use this service, add it to your component or directive as a dependency.
+ * The service is instantiated along with your component.
+ *
+ * Apps do not typically need to create their own animation players, but if you
+ * do need to, follow these steps:
+ *
+ * 1. Use the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code> method
+ * to create a programmatic animation. The method returns an `AnimationFactory` instance.
+ *
+ * 2. Use the factory object to create an `AnimationPlayer` and attach it to a DOM element.
+ *
+ * 3. Use the player object to control the animation programmatically.
+ *
+ * For example:
+ *
+ * ```ts
+ * // import the service from BrowserAnimationsModule
+ * import {AnimationBuilder} from '@angular/animations';
+ * // require the service as a dependency
+ * class MyCmp {
+ *   constructor(private _builder: AnimationBuilder) {}
+ *
+ *   makeAnimation(element: any) {
+ *     // first define a reusable animation
+ *     const myAnimation = this._builder.build([
+ *       style({ width: 0 }),
+ *       animate(1000, style({ width: '100px' }))
+ *     ]);
+ *
+ *     // use the returned factory object to create a player
+ *     const player = myAnimation.create(element);
+ *
+ *     player.play();
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+declare abstract class AnimationBuilder {
+    /**
+     * Builds a factory for producing a defined animation.
+     * @param animation A reusable animation definition.
+     * @returns A factory object that can create a player for the defined animation.
+     * @see {@link animate}
+     */
+    abstract build(animation: AnimationMetadata | AnimationMetadata[]): AnimationFactory;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnimationBuilder>;
+}
+/**
+ * A factory object returned from the
+ * <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>
+ * method.
+ *
+ * @publicApi
+ */
+declare abstract class AnimationFactory {
+    /**
+     * Creates an `AnimationPlayer` instance for the reusable animation defined by
+     * the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>
+     * method that created this factory and attaches the new player a DOM element.
+     *
+     * @param element The DOM element to which to attach the player.
+     * @param options A set of options that can include a time delay and
+     * additional developer-defined parameters.
+     */
+    abstract create(element: any, options?: AnimationOptions): AnimationPlayer;
+}
+declare class BrowserAnimationBuilder extends AnimationBuilder {
+    private animationModuleType;
+    private _nextAnimationId;
+    private _renderer;
+    constructor(rootRenderer: RendererFactory2, doc: Document);
+    build(animation: AnimationMetadata | AnimationMetadata[]): AnimationFactory;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserAnimationBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserAnimationBuilder>;
+}
+
+/**
+ * An instance of this class is returned as an event parameter when an animation
+ * callback is captured for an animation either during the start or done phase.
+ *
+ * ```ts
+ * @Component({
+ *   host: {
+ *     '[@myAnimationTrigger]': 'someExpression',
+ *     '(@myAnimationTrigger.start)': 'captureStartEvent($event)',
+ *     '(@myAnimationTrigger.done)': 'captureDoneEvent($event)',
+ *   },
+ *   animations: [
+ *     trigger("myAnimationTrigger", [
+ *        // ...
+ *     ])
+ *   ]
+ * })
+ * class MyComponent {
+ *   someExpression: any = false;
+ *   captureStartEvent(event: AnimationEvent) {
+ *     // the toState, fromState and totalTime data is accessible from the event variable
+ *   }
+ *
+ *   captureDoneEvent(event: AnimationEvent) {
+ *     // the toState, fromState and totalTime data is accessible from the event variable
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+interface AnimationEvent {
+    /**
+     * The name of the state from which the animation is triggered.
+     */
+    fromState: string;
+    /**
+     * The name of the state in which the animation completes.
+     */
+    toState: string;
+    /**
+     * The time it takes the animation to complete, in milliseconds.
+     */
+    totalTime: number;
+    /**
+     * The animation phase in which the callback was invoked, one of
+     * "start" or "done".
+     */
+    phaseName: string;
+    /**
+     * The element to which the animation is attached.
+     */
+    element: any;
+    /**
+     * Internal.
+     */
+    triggerName: string;
+    /**
+     * Internal.
+     */
+    disabled: boolean;
+}
+
+/**
+ * The list of error codes used in runtime code of the `animations` package.
+ * Reserved error code range: 3000-3999.
+ */
+declare const enum RuntimeErrorCode {
+    INVALID_TIMING_VALUE = 3000,
+    INVALID_STYLE_PARAMS = 3001,
+    INVALID_STYLE_VALUE = 3002,
+    INVALID_PARAM_VALUE = 3003,
+    INVALID_NODE_TYPE = 3004,
+    INVALID_CSS_UNIT_VALUE = 3005,
+    INVALID_TRIGGER = 3006,
+    INVALID_DEFINITION = 3007,
+    INVALID_STATE = 3008,
+    INVALID_PROPERTY = 3009,
+    INVALID_PARALLEL_ANIMATION = 3010,
+    INVALID_KEYFRAMES = 3011,
+    INVALID_OFFSET = 3012,
+    INVALID_STAGGER = 3013,
+    INVALID_QUERY = 3014,
+    INVALID_EXPRESSION = 3015,
+    INVALID_TRANSITION_ALIAS = 3016,
+    NEGATIVE_STEP_VALUE = 3100,
+    NEGATIVE_DELAY_VALUE = 3101,
+    KEYFRAME_OFFSETS_OUT_OF_ORDER = 3200,
+    KEYFRAMES_MISSING_OFFSETS = 3202,
+    MISSING_OR_DESTROYED_ANIMATION = 3300,
+    MISSING_PLAYER = 3301,
+    MISSING_TRIGGER = 3302,
+    MISSING_EVENT = 3303,
+    UNSUPPORTED_TRIGGER_EVENT = 3400,
+    UNREGISTERED_TRIGGER = 3401,
+    TRIGGER_TRANSITIONS_FAILED = 3402,
+    TRIGGER_PARSING_FAILED = 3403,
+    TRIGGER_BUILD_FAILED = 3404,
+    VALIDATION_FAILED = 3500,
+    BUILDING_FAILED = 3501,
+    ANIMATION_FAILED = 3502,
+    REGISTRATION_FAILED = 3503,
+    CREATE_ANIMATION_FAILED = 3504,
+    TRANSITION_FAILED = 3505,
+    BROWSER_ANIMATION_BUILDER_INJECTED_WITHOUT_ANIMATIONS = 3600
+}
+
+/**
+ * A programmatic controller for a group of reusable animations.
+ * Used internally to control animations.
+ *
+ * @see {@link AnimationPlayer}
+ * @see {@link animations/group group}
+ *
+ */
+declare class AnimationGroupPlayer implements AnimationPlayer {
+    private _onDoneFns;
+    private _onStartFns;
+    private _finished;
+    private _started;
+    private _destroyed;
+    private _onDestroyFns;
+    parentPlayer: AnimationPlayer | null;
+    totalTime: number;
+    readonly players: AnimationPlayer[];
+    constructor(_players: AnimationPlayer[]);
+    private _onFinish;
+    init(): void;
+    onStart(fn: () => void): void;
+    private _onStart;
+    onDone(fn: () => void): void;
+    onDestroy(fn: () => void): void;
+    hasStarted(): boolean;
+    play(): void;
+    pause(): void;
+    restart(): void;
+    finish(): void;
+    destroy(): void;
+    private _onDestroy;
+    reset(): void;
+    setPosition(p: number): void;
+    getPosition(): number;
+    beforeDestroy(): void;
+}
+
+declare const ɵPRE_STYLE = "!";
+
+export { AnimationBuilder, AnimationFactory, AnimationMetadata, AnimationOptions, AnimationPlayer, AnimationGroupPlayer as ɵAnimationGroupPlayer, BrowserAnimationBuilder as ɵBrowserAnimationBuilder, ɵPRE_STYLE, RuntimeErrorCode as ɵRuntimeErrorCode };
+export type { AnimationEvent };

node_modules/@angular/animations/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@angular/animations",
+  "version": "19.2.13",
+  "description": "Angular - animations integration with web-animations",
+  "author": "angular",
+  "license": "MIT",
+  "engines": {
+    "node": "^18.19.1 || ^20.11.1 || >=22.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@angular/core": "19.2.13",
+    "@angular/common": "19.2.13"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/angular/angular.git",
+    "directory": "packages/animations"
+  },
+  "ng-update": {
+    "packageGroup": [
+      "@angular/core",
+      "@angular/bazel",
+      "@angular/common",
+      "@angular/compiler",
+      "@angular/compiler-cli",
+      "@angular/animations",
+      "@angular/elements",
+      "@angular/platform-browser",
+      "@angular/platform-browser-dynamic",
+      "@angular/forms",
+      "@angular/platform-server",
+      "@angular/upgrade",
+      "@angular/router",
+      "@angular/language-service",
+      "@angular/localize",
+      "@angular/service-worker"
+    ]
+  },
+  "sideEffects": false,
+  "module": "./fesm2022/animations.mjs",
+  "typings": "./index.d.ts",
+  "type": "module",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/animations.mjs"
+    },
+    "./browser": {
+      "types": "./browser/index.d.ts",
+      "default": "./fesm2022/browser.mjs"
+    },
+    "./browser/testing": {
+      "types": "./browser/testing/index.d.ts",
+      "default": "./fesm2022/browser/testing.mjs"
+    }
+  }
+}

node_modules/@angular/cdk/LICENSE

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

node_modules/@angular/cdk/README.md

@@ -0,0 +1,6 @@
+Angular Material
+=======
+
+The sources for this package are in the main [Angular Material](https://github.com/angular/components) repo. Please file issues and pull requests against that repo.
+
+License: MIT

node_modules/@angular/cdk/_adev_assets/cdk_drag_drop.json

@@ -0,0 +1,7392 @@
+{
+  "repo": "angular/components",
+  "moduleLabel": "@angular/cdk/drag-drop",
+  "moduleName": "@angular/cdk/drag-drop",
+  "normalizedModuleName": "angular_cdk_drag-drop",
+  "entries": [
+    {
+      "name": "moveItemInArray",
+      "signatures": [
+        {
+          "name": "moveItemInArray",
+          "entryType": "function",
+          "description": "Moves an item one index in an array to another.",
+          "generics": [
+            {
+              "name": "T",
+              "default": "any"
+            }
+          ],
+          "isNewType": false,
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Array in which to move the item."
+            },
+            {
+              "name": "param",
+              "comment": "Starting index of the item."
+            },
+            {
+              "name": "param",
+              "comment": "Index to which the item should be moved."
+            }
+          ],
+          "params": [
+            {
+              "name": "array",
+              "description": "Array in which to move the item.",
+              "type": "T[]",
+              "isOptional": false,
+              "isRestParam": false
+            },
+            {
+              "name": "fromIndex",
+              "description": "Starting index of the item.",
+              "type": "number",
+              "isOptional": false,
+              "isRestParam": false
+            },
+            {
+              "name": "toIndex",
+              "description": "Index to which the item should be moved.",
+              "type": "number",
+              "isOptional": false,
+              "isRestParam": false
+            }
+          ],
+          "rawComment": "/**\n * Moves an item one index in an array to another.\n * @param array Array in which to move the item.\n * @param fromIndex Starting index of the item.\n * @param toIndex Index to which the item should be moved.\n */",
+          "returnType": "void"
+        }
+      ],
+      "implementation": {
+        "params": [
+          {
+            "name": "array",
+            "description": "Array in which to move the item.",
+            "type": "T[]",
+            "isOptional": false,
+            "isRestParam": false
+          },
+          {
+            "name": "fromIndex",
+            "description": "Starting index of the item.",
+            "type": "number",
+            "isOptional": false,
+            "isRestParam": false
+          },
+          {
+            "name": "toIndex",
+            "description": "Index to which the item should be moved.",
+            "type": "number",
+            "isOptional": false,
+            "isRestParam": false
+          }
+        ],
+        "isNewType": false,
+        "returnType": "void",
+        "generics": [
+          {
+            "name": "T",
+            "default": "any"
+          }
+        ],
+        "name": "moveItemInArray",
+        "description": "Moves an item one index in an array to another.",
+        "entryType": "function",
+        "jsdocTags": [
+          {
+            "name": "param",
+            "comment": "Array in which to move the item."
+          },
+          {
+            "name": "param",
+            "comment": "Starting index of the item."
+          },
+          {
+            "name": "param",
+            "comment": "Index to which the item should be moved."
+          }
+        ],
+        "rawComment": "/**\n * Moves an item one index in an array to another.\n * @param array Array in which to move the item.\n * @param fromIndex Starting index of the item.\n * @param toIndex Index to which the item should be moved.\n */"
+      },
+      "entryType": "function",
+      "description": "Moves an item one index in an array to another.",
+      "jsdocTags": [
+        {
+          "name": "param",
+          "comment": "Array in which to move the item."
+        },
+        {
+          "name": "param",
+          "comment": "Starting index of the item."
+        },
+        {
+          "name": "param",
+          "comment": "Index to which the item should be moved."
+        }
+      ],
+      "rawComment": "/**\n * Moves an item one index in an array to another.\n * @param array Array in which to move the item.\n * @param fromIndex Starting index of the item.\n * @param toIndex Index to which the item should be moved.\n */",
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-utils.ts",
+        "startLine": 15,
+        "endLine": 31
+      }
+    },
+    {
+      "name": "CdkDragStart",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "source",
+          "type": "CdkDrag<T>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Draggable that emitted the event.",
+          "jsdocTags": []
+        },
+        {
+          "name": "event",
+          "type": "MouseEvent | TouchEvent",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Native event that started the drag sequence.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        }
+      ],
+      "description": "Event emitted when the user starts dragging a draggable.",
+      "jsdocTags": [],
+      "rawComment": "/** Event emitted when the user starts dragging a draggable. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-events.ts",
+        "startLine": 13,
+        "endLine": 18
+      }
+    },
+    {
+      "name": "DragStartDelay",
+      "type": "number | {touch: number; mouse: number}",
+      "entryType": "type_alias",
+      "generics": [],
+      "rawComment": "/** Possible values that can be used to configure the drag start delay. */",
+      "description": "Possible values that can be used to configure the drag start delay.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "src/cdk/drag-drop/directives/config.ts",
+        "startLine": 13,
+        "endLine": 13
+      }
+    },
+    {
+      "name": "DragAxis",
+      "type": "'x' | 'y'",
+      "entryType": "type_alias",
+      "generics": [],
+      "rawComment": "/** Possible axis along which dragging can be locked. */",
+      "description": "Possible axis along which dragging can be locked.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "src/cdk/drag-drop/directives/config.ts",
+        "startLine": 16,
+        "endLine": 16
+      }
+    },
+    {
+      "name": "CDK_DRAG_PARENT",
+      "type": "any",
+      "entryType": "constant",
+      "rawComment": "/**\n * Injection token that can be used for a `CdkDrag` to provide itself as a parent to the\n * drag-specific child directive (`CdkDragHandle`, `CdkDragPreview` etc.). Used primarily\n * to avoid circular imports.\n * @docs-private\n */",
+      "description": "Injection token that can be used for a `CdkDrag` to provide itself as a parent to the\ndrag-specific child directive (`CdkDragHandle`, `CdkDragPreview` etc.). Used primarily\nto avoid circular imports.",
+      "jsdocTags": [
+        {
+          "name": "docs-private",
+          "comment": ""
+        }
+      ],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-parent.ts",
+        "startLine": 18,
+        "endLine": 18
+      }
+    },
+    {
+      "name": "DragConstrainPosition",
+      "type": "(point: Point, dragRef: DragRef) => Point",
+      "entryType": "type_alias",
+      "generics": [],
+      "rawComment": "/** Function that can be used to constrain the position of a dragged element. */",
+      "description": "Function that can be used to constrain the position of a dragged element.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "src/cdk/drag-drop/directives/config.ts",
+        "startLine": 19,
+        "endLine": 19
+      }
+    },
+    {
+      "name": "CDK_DROP_LIST_GROUP",
+      "type": "any",
+      "entryType": "constant",
+      "rawComment": "/**\n * Injection token that can be used to reference instances of `CdkDropListGroup`. It serves as\n * alternative token to the actual `CdkDropListGroup` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */",
+      "description": "Injection token that can be used to reference instances of `CdkDropListGroup`. It serves as\nalternative token to the actual `CdkDropListGroup` class which could cause unnecessary\nretention of the class and its directive metadata.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drop-list-group.ts",
+        "startLine": 16,
+        "endLine": 18
+      }
+    },
+    {
+      "name": "CdkDragRelease",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "source",
+          "type": "CdkDrag<T>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Draggable that emitted the event.",
+          "jsdocTags": []
+        },
+        {
+          "name": "event",
+          "type": "MouseEvent | TouchEvent",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Native event that caused the release event.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        }
+      ],
+      "description": "Event emitted when the user releases an item, before any animations have started.",
+      "jsdocTags": [],
+      "rawComment": "/** Event emitted when the user releases an item, before any animations have started. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-events.ts",
+        "startLine": 21,
+        "endLine": 26
+      }
+    },
+    {
+      "name": "CDK_DRAG_PLACEHOLDER",
+      "type": "any",
+      "entryType": "constant",
+      "rawComment": "/**\n * Injection token that can be used to reference instances of `CdkDragPlaceholder`. It serves as\n * alternative token to the actual `CdkDragPlaceholder` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */",
+      "description": "Injection token that can be used to reference instances of `CdkDragPlaceholder`. It serves as\nalternative token to the actual `CdkDragPlaceholder` class which could cause unnecessary\nretention of the class and its directive metadata.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drag-placeholder.ts",
+        "startLine": 17,
+        "endLine": 17
+      }
+    },
+    {
+      "name": "CDK_DRAG_PREVIEW",
+      "type": "any",
+      "entryType": "constant",
+      "rawComment": "/**\n * Injection token that can be used to reference instances of `CdkDragPreview`. It serves as\n * alternative token to the actual `CdkDragPreview` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */",
+      "description": "Injection token that can be used to reference instances of `CdkDragPreview`. It serves as\nalternative token to the actual `CdkDragPreview` class which could cause unnecessary\nretention of the class and its directive metadata.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drag-preview.ts",
+        "startLine": 25,
+        "endLine": 25
+      }
+    },
+    {
+      "name": "CdkDropListGroup",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "disabled",
+          "type": "boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Whether starting a dragging sequence from inside this group is disabled.",
+          "jsdocTags": []
+        },
+        {
+          "name": "ngOnDestroy",
+          "signatures": [
+            {
+              "name": "ngOnDestroy",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "ngOnDestroy",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T"
+        }
+      ],
+      "description": "Declaratively connects sibling `cdkDropList` instances together. All of the `cdkDropList`\nelements that are placed inside a `cdkDropListGroup` will be connected to each other\nautomatically. Can be used as an alternative to the `cdkDropListConnectedTo` input\nfrom `cdkDropList`.",
+      "jsdocTags": [],
+      "rawComment": "/**\n * Declaratively connects sibling `cdkDropList` instances together. All of the `cdkDropList`\n * elements that are placed inside a `cdkDropListGroup` will be connected to each other\n * automatically. Can be used as an alternative to the `cdkDropListConnectedTo` input\n * from `cdkDropList`.\n */",
+      "implements": [
+        "OnDestroy"
+      ],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drop-list-group.ts",
+        "startLine": 26,
+        "endLine": 42
+      }
+    },
+    {
+      "name": "DragDrop",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [
+            {
+              "name": "constructor",
+              "params": [
+                {
+                  "name": "args",
+                  "description": "",
+                  "type": "unknown[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "returnType": "DragDrop",
+              "description": "",
+              "entryType": "function",
+              "jsdocTags": [],
+              "rawComment": "",
+              "generics": [],
+              "isNewType": false
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "DragDrop",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "createDrag",
+          "signatures": [
+            {
+              "name": "createDrag",
+              "entryType": "function",
+              "description": "Turns an element into a draggable item.",
+              "generics": [
+                {
+                  "name": "T",
+                  "default": "any"
+                }
+              ],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Element to which to attach the dragging functionality."
+                },
+                {
+                  "name": "param",
+                  "comment": "Object used to configure the dragging behavior."
+                }
+              ],
+              "params": [
+                {
+                  "name": "element",
+                  "description": "Element to which to attach the dragging functionality.",
+                  "type": "any",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "config",
+                  "description": "Object used to configure the dragging behavior.",
+                  "type": "DragRefConfig",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Turns an element into a draggable item.\n   * @param element Element to which to attach the dragging functionality.\n   * @param config Object used to configure the dragging behavior.\n   */",
+              "returnType": "DragRef<T>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "Element to which to attach the dragging functionality.",
+                "type": "any",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "config",
+                "description": "Object used to configure the dragging behavior.",
+                "type": "DragRefConfig",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "DragRef<T>",
+            "generics": [
+              {
+                "name": "T",
+                "default": "any"
+              }
+            ],
+            "name": "createDrag",
+            "description": "Turns an element into a draggable item.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Element to which to attach the dragging functionality."
+              },
+              {
+                "name": "param",
+                "comment": "Object used to configure the dragging behavior."
+              }
+            ],
+            "rawComment": "/**\n   * Turns an element into a draggable item.\n   * @param element Element to which to attach the dragging functionality.\n   * @param config Object used to configure the dragging behavior.\n   */"
+          },
+          "entryType": "function",
+          "description": "Turns an element into a draggable item.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Element to which to attach the dragging functionality."
+            },
+            {
+              "name": "param",
+              "comment": "Object used to configure the dragging behavior."
+            }
+          ],
+          "rawComment": "/**\n   * Turns an element into a draggable item.\n   * @param element Element to which to attach the dragging functionality.\n   * @param config Object used to configure the dragging behavior.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "createDropList",
+          "signatures": [
+            {
+              "name": "createDropList",
+              "entryType": "function",
+              "description": "Turns an element into a drop list.",
+              "generics": [
+                {
+                  "name": "T",
+                  "default": "any"
+                }
+              ],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Element to which to attach the drop list functionality."
+                }
+              ],
+              "params": [
+                {
+                  "name": "element",
+                  "description": "Element to which to attach the drop list functionality.",
+                  "type": "any",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Turns an element into a drop list.\n   * @param element Element to which to attach the drop list functionality.\n   */",
+              "returnType": "DropListRef<T>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "Element to which to attach the drop list functionality.",
+                "type": "any",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "DropListRef<T>",
+            "generics": [
+              {
+                "name": "T",
+                "default": "any"
+              }
+            ],
+            "name": "createDropList",
+            "description": "Turns an element into a drop list.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Element to which to attach the drop list functionality."
+              }
+            ],
+            "rawComment": "/**\n   * Turns an element into a drop list.\n   * @param element Element to which to attach the drop list functionality.\n   */"
+          },
+          "entryType": "function",
+          "description": "Turns an element into a drop list.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Element to which to attach the drop list functionality."
+            }
+          ],
+          "rawComment": "/**\n   * Turns an element into a drop list.\n   * @param element Element to which to attach the drop list functionality.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [],
+      "description": "Service that allows for drag-and-drop functionality to be attached to DOM elements.",
+      "jsdocTags": [],
+      "rawComment": "/**\n * Service that allows for drag-and-drop functionality to be attached to DOM elements.\n */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-drop.ts",
+        "startLine": 25,
+        "endLine": 69
+      }
+    },
+    {
+      "name": "CdkDragPlaceholder",
+      "isAbstract": false,
+      "entryType": "directive",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [
+            {
+              "name": "constructor",
+              "params": [
+                {
+                  "name": "args",
+                  "description": "",
+                  "type": "unknown[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "returnType": "CdkDragPlaceholder",
+              "description": "",
+              "entryType": "function",
+              "jsdocTags": [],
+              "rawComment": "",
+              "generics": [],
+              "isNewType": false
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "CdkDragPlaceholder<T>",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "templateRef",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "data",
+          "type": "T",
+          "memberType": "property",
+          "memberTags": [
+            "input"
+          ],
+          "description": "Context data to be added to the placeholder template instance.",
+          "jsdocTags": [],
+          "inputAlias": "data",
+          "isRequiredInput": false
+        },
+        {
+          "name": "ngOnDestroy",
+          "signatures": [
+            {
+              "name": "ngOnDestroy",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "ngOnDestroy",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        }
+      ],
+      "description": "Element that will be used as a template for the placeholder of a CdkDrag when\nit is being dragged. The placeholder is displayed in place of the element being dragged.",
+      "jsdocTags": [],
+      "rawComment": "/**\n * Element that will be used as a template for the placeholder of a CdkDrag when\n * it is being dragged. The placeholder is displayed in place of the element being dragged.\n */",
+      "implements": [
+        "OnDestroy"
+      ],
+      "isStandalone": true,
+      "selector": "ng-template[cdkDragPlaceholder]",
+      "exportAs": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drag-placeholder.ts",
+        "startLine": 23,
+        "endLine": 44
+      }
+    },
+    {
+      "name": "DropListOrientation",
+      "type": "'horizontal' | 'vertical' | 'mixed'",
+      "entryType": "type_alias",
+      "generics": [],
+      "rawComment": "/** Possible orientations for a drop list. */",
+      "description": "Possible orientations for a drop list.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "src/cdk/drag-drop/directives/config.ts",
+        "startLine": 22,
+        "endLine": 22
+      }
+    },
+    {
+      "name": "CdkDragPreview",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [
+            {
+              "name": "constructor",
+              "params": [
+                {
+                  "name": "args",
+                  "description": "",
+                  "type": "unknown[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "returnType": "CdkDragPreview",
+              "description": "",
+              "entryType": "function",
+              "jsdocTags": [],
+              "rawComment": "",
+              "generics": [],
+              "isNewType": false
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "CdkDragPreview<T>",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "templateRef",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "data",
+          "type": "T",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Context data to be added to the preview template instance.",
+          "jsdocTags": []
+        },
+        {
+          "name": "matchSize",
+          "type": "boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Whether the preview should preserve the same size as the item that is being dragged.",
+          "jsdocTags": []
+        },
+        {
+          "name": "ngOnDestroy",
+          "signatures": [
+            {
+              "name": "ngOnDestroy",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "ngOnDestroy",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        }
+      ],
+      "description": "Element that will be used as a template for the preview\nof a CdkDrag when it is being dragged.",
+      "jsdocTags": [],
+      "rawComment": "/**\n * Element that will be used as a template for the preview\n * of a CdkDrag when it is being dragged.\n */",
+      "implements": [
+        "OnDestroy"
+      ],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drag-preview.ts",
+        "startLine": 31,
+        "endLine": 55
+      }
+    },
+    {
+      "name": "DragDropModule",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [],
+      "generics": [],
+      "description": "",
+      "jsdocTags": [],
+      "rawComment": "",
+      "implements": [],
+      "source": {
+        "filePath": "src/cdk/drag-drop/drag-drop-module.ts",
+        "startLine": 28,
+        "endLine": 33
+      }
+    },
+    {
+      "name": "CDK_DRAG_HANDLE",
+      "type": "any",
+      "entryType": "constant",
+      "rawComment": "/**\n * Injection token that can be used to reference instances of `CdkDragHandle`. It serves as\n * alternative token to the actual `CdkDragHandle` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */",
+      "description": "Injection token that can be used to reference instances of `CdkDragHandle`. It serves as\nalternative token to the actual `CdkDragHandle` class which could cause unnecessary\nretention of the class and its directive metadata.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drag-handle.ts",
+        "startLine": 30,
+        "endLine": 30
+      }
+    },
+    {
+      "name": "transferArrayItem",
+      "signatures": [
+        {
+          "name": "transferArrayItem",
+          "entryType": "function",
+          "description": "Moves an item from one array to another.",
+          "generics": [
+            {
+              "name": "T",
+              "default": "any"
+            }
+          ],
+          "isNewType": false,
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Array from which to transfer the item."
+            },
+            {
+              "name": "param",
+              "comment": "Array into which to put the item."
+            },
+            {
+              "name": "param",
+              "comment": "Index of the item in its current array."
+            },
+            {
+              "name": "param",
+              "comment": "Index at which to insert the item."
+            }
+          ],
+          "params": [
+            {
+              "name": "currentArray",
+              "description": "Array from which to transfer the item.",
+              "type": "T[]",
+              "isOptional": false,
+              "isRestParam": false
+            },
+            {
+              "name": "targetArray",
+              "description": "Array into which to put the item.",
+              "type": "T[]",
+              "isOptional": false,
+              "isRestParam": false
+            },
+            {
+              "name": "currentIndex",
+              "description": "Index of the item in its current array.",
+              "type": "number",
+              "isOptional": false,
+              "isRestParam": false
+            },
+            {
+              "name": "targetIndex",
+              "description": "Index at which to insert the item.",
+              "type": "number",
+              "isOptional": false,
+              "isRestParam": false
+            }
+          ],
+          "rawComment": "/**\n * Moves an item from one array to another.\n * @param currentArray Array from which to transfer the item.\n * @param targetArray Array into which to put the item.\n * @param currentIndex Index of the item in its current array.\n * @param targetIndex Index at which to insert the item.\n */",
+          "returnType": "void"
+        }
+      ],
+      "implementation": {
+        "params": [
+          {
+            "name": "currentArray",
+            "description": "Array from which to transfer the item.",
+            "type": "T[]",
+            "isOptional": false,
+            "isRestParam": false
+          },
+          {
+            "name": "targetArray",
+            "description": "Array into which to put the item.",
+            "type": "T[]",
+            "isOptional": false,
+            "isRestParam": false
+          },
+          {
+            "name": "currentIndex",
+            "description": "Index of the item in its current array.",
+            "type": "number",
+            "isOptional": false,
+            "isRestParam": false
+          },
+          {
+            "name": "targetIndex",
+            "description": "Index at which to insert the item.",
+            "type": "number",
+            "isOptional": false,
+            "isRestParam": false
+          }
+        ],
+        "isNewType": false,
+        "returnType": "void",
+        "generics": [
+          {
+            "name": "T",
+            "default": "any"
+          }
+        ],
+        "name": "transferArrayItem",
+        "description": "Moves an item from one array to another.",
+        "entryType": "function",
+        "jsdocTags": [
+          {
+            "name": "param",
+            "comment": "Array from which to transfer the item."
+          },
+          {
+            "name": "param",
+            "comment": "Array into which to put the item."
+          },
+          {
+            "name": "param",
+            "comment": "Index of the item in its current array."
+          },
+          {
+            "name": "param",
+            "comment": "Index at which to insert the item."
+          }
+        ],
+        "rawComment": "/**\n * Moves an item from one array to another.\n * @param currentArray Array from which to transfer the item.\n * @param targetArray Array into which to put the item.\n * @param currentIndex Index of the item in its current array.\n * @param targetIndex Index at which to insert the item.\n */"
+      },
+      "entryType": "function",
+      "description": "Moves an item from one array to another.",
+      "jsdocTags": [
+        {
+          "name": "param",
+          "comment": "Array from which to transfer the item."
+        },
+        {
+          "name": "param",
+          "comment": "Array into which to put the item."
+        },
+        {
+          "name": "param",
+          "comment": "Index of the item in its current array."
+        },
+        {
+          "name": "param",
+          "comment": "Index at which to insert the item."
+        }
+      ],
+      "rawComment": "/**\n * Moves an item from one array to another.\n * @param currentArray Array from which to transfer the item.\n * @param targetArray Array into which to put the item.\n * @param currentIndex Index of the item in its current array.\n * @param targetIndex Index at which to insert the item.\n */",
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-utils.ts",
+        "startLine": 40,
+        "endLine": 52
+      }
+    },
+    {
+      "name": "CdkDragEnd",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "source",
+          "type": "CdkDrag<T>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Draggable that emitted the event.",
+          "jsdocTags": []
+        },
+        {
+          "name": "distance",
+          "type": "{ x: number; y: number; }",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Distance in pixels that the user has dragged since the drag sequence started.",
+          "jsdocTags": []
+        },
+        {
+          "name": "dropPoint",
+          "type": "{ x: number; y: number; }",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Position where the pointer was when the item was dropped",
+          "jsdocTags": []
+        },
+        {
+          "name": "event",
+          "type": "MouseEvent | TouchEvent",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Native event that caused the dragging to stop.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        }
+      ],
+      "description": "Event emitted when the user stops dragging a draggable.",
+      "jsdocTags": [],
+      "rawComment": "/** Event emitted when the user stops dragging a draggable. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-events.ts",
+        "startLine": 29,
+        "endLine": 38
+      }
+    },
+    {
+      "name": "CdkDragHandle",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [
+            {
+              "name": "constructor",
+              "params": [
+                {
+                  "name": "args",
+                  "description": "",
+                  "type": "unknown[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "returnType": "CdkDragHandle",
+              "description": "",
+              "entryType": "function",
+              "jsdocTags": [],
+              "rawComment": "",
+              "generics": [],
+              "isNewType": false
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "CdkDragHandle",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "element",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "disabled",
+          "type": "boolean",
+          "memberType": "getter",
+          "memberTags": [],
+          "description": "Whether starting to drag through this handle is disabled.",
+          "jsdocTags": []
+        },
+        {
+          "name": "disabled",
+          "type": "boolean",
+          "memberType": "setter",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "ngAfterViewInit",
+          "signatures": [
+            {
+              "name": "ngAfterViewInit",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "ngAfterViewInit",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "ngOnDestroy",
+          "signatures": [
+            {
+              "name": "ngOnDestroy",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "ngOnDestroy",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [],
+      "description": "Handle that can be used to drag a CdkDrag instance.",
+      "jsdocTags": [],
+      "rawComment": "/** Handle that can be used to drag a CdkDrag instance. */",
+      "implements": [
+        "AfterViewInit",
+        "OnDestroy"
+      ],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drag-handle.ts",
+        "startLine": 33,
+        "endLine": 89
+      }
+    },
+    {
+      "name": "CDK_DRAG_CONFIG",
+      "type": "any",
+      "entryType": "constant",
+      "rawComment": "/**\n * Injection token that can be used to configure the\n * behavior of the drag&drop-related components.\n */",
+      "description": "Injection token that can be used to configure the\nbehavior of the drag&drop-related components.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "src/cdk/drag-drop/directives/config.ts",
+        "startLine": 28,
+        "endLine": 28
+      }
+    },
+    {
+      "name": "DragDropConfig",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "lockAxis",
+          "type": "DragAxis | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "dragStartDelay",
+          "type": "DragStartDelay | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "constrainPosition",
+          "type": "DragConstrainPosition | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "previewClass",
+          "type": "string | string[] | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "boundaryElement",
+          "type": "string | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "rootElementSelector",
+          "type": "string | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "draggingDisabled",
+          "type": "boolean | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "sortingDisabled",
+          "type": "boolean | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "listAutoScrollDisabled",
+          "type": "boolean | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "listOrientation",
+          "type": "DropListOrientation | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "zIndex",
+          "type": "number | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "previewContainer",
+          "type": "\"global\" | \"parent\" | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "dragStartThreshold",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [
+            "override"
+          ],
+          "description": "Minimum amount of pixels that the user should\ndrag, before the CDK initiates a drag sequence.",
+          "jsdocTags": []
+        },
+        {
+          "name": "pointerDirectionChangeThreshold",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [
+            "override"
+          ],
+          "description": "Amount the pixels the user should drag before the CDK\nconsiders them to have changed the drag direction.",
+          "jsdocTags": []
+        },
+        {
+          "name": "parentDragRef",
+          "type": "DragRef<any> | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional",
+            "override"
+          ],
+          "description": "Ref that the current drag item is nested in.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [],
+      "description": "Object that can be used to configure the drag\nitems and drop lists within a module or a component.",
+      "jsdocTags": [],
+      "rawComment": "/**\n * Object that can be used to configure the drag\n * items and drop lists within a module or a component.\n */",
+      "extends": "Partial<DragRefConfig>",
+      "implements": [],
+      "source": {
+        "filePath": "src/cdk/drag-drop/directives/config.ts",
+        "startLine": 34,
+        "endLine": 47
+      }
+    },
+    {
+      "name": "CdkDropList",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [
+            {
+              "name": "constructor",
+              "params": [
+                {
+                  "name": "args",
+                  "description": "",
+                  "type": "unknown[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "returnType": "CdkDropList",
+              "description": "",
+              "entryType": "function",
+              "jsdocTags": [],
+              "rawComment": "",
+              "generics": [],
+              "isNewType": false
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "CdkDropList<T>",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "element",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "connectedTo",
+          "type": "string | CdkDropList<any> | (string | CdkDropList<any>)[]",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Other draggable containers that this container is connected to and into which the\ncontainer's items can be transferred. Can either be references to other drop containers,\nor their unique IDs.",
+          "jsdocTags": []
+        },
+        {
+          "name": "data",
+          "type": "T",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Arbitrary data to attach to this container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "orientation",
+          "type": "DropListOrientation",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Direction in which the list is oriented.",
+          "jsdocTags": []
+        },
+        {
+          "name": "id",
+          "type": "string",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Unique ID for the drop zone. Can be used as a reference\nin the `connectedTo` of another `CdkDropList`.",
+          "jsdocTags": []
+        },
+        {
+          "name": "lockAxis",
+          "type": "DragAxis",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Locks the position of the draggable elements inside the container along the specified axis.",
+          "jsdocTags": []
+        },
+        {
+          "name": "disabled",
+          "type": "boolean",
+          "memberType": "getter",
+          "memberTags": [],
+          "description": "Whether starting a dragging sequence from this container is disabled.",
+          "jsdocTags": []
+        },
+        {
+          "name": "disabled",
+          "type": "boolean",
+          "memberType": "setter",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "sortingDisabled",
+          "type": "boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Whether sorting within this drop list is disabled.",
+          "jsdocTags": []
+        },
+        {
+          "name": "enterPredicate",
+          "type": "(drag: CdkDrag<any>, drop: CdkDropList<any>) => boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Function that is used to determine whether an item\nis allowed to be moved into a drop container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "sortPredicate",
+          "type": "(index: number, drag: CdkDrag<any>, drop: CdkDropList<any>) => boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Functions that is used to determine whether an item can be sorted into a particular index.",
+          "jsdocTags": []
+        },
+        {
+          "name": "autoScrollDisabled",
+          "type": "boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Whether to auto-scroll the view when the user moves their pointer close to the edges.",
+          "jsdocTags": []
+        },
+        {
+          "name": "autoScrollStep",
+          "type": "NumberInput",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Number of pixels to scroll for each frame when auto-scrolling an element.",
+          "jsdocTags": []
+        },
+        {
+          "name": "elementContainerSelector",
+          "type": "string | null",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Selector that will be used to resolve an alternate element container for the drop list.\nPassing an alternate container is useful for the cases where one might not have control\nover the parent node of the draggable items within the list (e.g. due to content projection).\nThis allows for usages like:\n\n```\n<div cdkDropList cdkDropListElementContainer=\".inner\">\n  <div class=\"inner\">\n    <div cdkDrag></div>\n  </div>\n</div>\n```",
+          "jsdocTags": []
+        },
+        {
+          "name": "dropped",
+          "type": "EventEmitter<CdkDragDrop<T, any, any>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user drops an item inside the container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "entered",
+          "type": "EventEmitter<CdkDragEnter<T, T>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user has moved a new drag item into this container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "exited",
+          "type": "EventEmitter<CdkDragExit<T, T>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user removes an item from the container\nby dragging it into another container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "sorted",
+          "type": "EventEmitter<CdkDragSortEvent<T, T>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits as the user is swapping items while actively dragging.",
+          "jsdocTags": []
+        },
+        {
+          "name": "addItem",
+          "signatures": [
+            {
+              "name": "addItem",
+              "entryType": "function",
+              "description": "Registers an items with the drop list.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "item",
+                  "description": "",
+                  "type": "CdkDrag<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Registers an items with the drop list. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "item",
+                "description": "",
+                "type": "CdkDrag<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "addItem",
+            "description": "Registers an items with the drop list.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Registers an items with the drop list. */"
+          },
+          "entryType": "function",
+          "description": "Registers an items with the drop list.",
+          "jsdocTags": [],
+          "rawComment": "/** Registers an items with the drop list. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "removeItem",
+          "signatures": [
+            {
+              "name": "removeItem",
+              "entryType": "function",
+              "description": "Removes an item from the drop list.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "item",
+                  "description": "",
+                  "type": "CdkDrag<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Removes an item from the drop list. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "item",
+                "description": "",
+                "type": "CdkDrag<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "removeItem",
+            "description": "Removes an item from the drop list.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Removes an item from the drop list. */"
+          },
+          "entryType": "function",
+          "description": "Removes an item from the drop list.",
+          "jsdocTags": [],
+          "rawComment": "/** Removes an item from the drop list. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getSortedItems",
+          "signatures": [
+            {
+              "name": "getSortedItems",
+              "entryType": "function",
+              "description": "Gets the registered items in the list, sorted by their position in the DOM.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Gets the registered items in the list, sorted by their position in the DOM. */",
+              "returnType": "CdkDrag<any>[]"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "CdkDrag<any>[]",
+            "generics": [],
+            "name": "getSortedItems",
+            "description": "Gets the registered items in the list, sorted by their position in the DOM.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the registered items in the list, sorted by their position in the DOM. */"
+          },
+          "entryType": "function",
+          "description": "Gets the registered items in the list, sorted by their position in the DOM.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the registered items in the list, sorted by their position in the DOM. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "ngOnDestroy",
+          "signatures": [
+            {
+              "name": "ngOnDestroy",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "ngOnDestroy",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        }
+      ],
+      "description": "Container that wraps a set of draggable items.",
+      "jsdocTags": [],
+      "rawComment": "/** Container that wraps a set of draggable items. */",
+      "implements": [
+        "OnDestroy"
+      ],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drop-list.ts",
+        "startLine": 36,
+        "endLine": 423
+      }
+    },
+    {
+      "name": "DragRefConfig",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "dragStartThreshold",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Minimum amount of pixels that the user should\ndrag, before the CDK initiates a drag sequence.",
+          "jsdocTags": []
+        },
+        {
+          "name": "pointerDirectionChangeThreshold",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Amount the pixels the user should drag before the CDK\nconsiders them to have changed the drag direction.",
+          "jsdocTags": []
+        },
+        {
+          "name": "zIndex",
+          "type": "number | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "`z-index` for the absolutely-positioned elements that are created by the drag item.",
+          "jsdocTags": []
+        },
+        {
+          "name": "parentDragRef",
+          "type": "DragRef<any> | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "Ref that the current drag item is nested in.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [],
+      "description": "Object that can be used to configure the behavior of DragRef.",
+      "jsdocTags": [],
+      "rawComment": "/** Object that can be used to configure the behavior of DragRef. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-ref.ts",
+        "startLine": 40,
+        "endLine": 58
+      }
+    },
+    {
+      "name": "DragDropRegistry",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [
+            {
+              "name": "constructor",
+              "params": [
+                {
+                  "name": "args",
+                  "description": "",
+                  "type": "unknown[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "returnType": "DragDropRegistry",
+              "description": "",
+              "entryType": "function",
+              "jsdocTags": [],
+              "rawComment": "",
+              "generics": [],
+              "isNewType": false
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "DragDropRegistry<_, __>",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "pointerMove",
+          "type": "Subject<MouseEvent | TouchEvent>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits the `touchmove` or `mousemove` events that are dispatched\nwhile the user is dragging a drag item instance.",
+          "jsdocTags": []
+        },
+        {
+          "name": "pointerUp",
+          "type": "Subject<MouseEvent | TouchEvent>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits the `touchend` or `mouseup` events that are dispatched\nwhile the user is dragging a drag item instance.",
+          "jsdocTags": []
+        },
+        {
+          "name": "scroll",
+          "type": "Subject<Event>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the viewport has been scrolled while the user is dragging an item.",
+          "jsdocTags": [
+            {
+              "name": "deprecated",
+              "comment": "To be turned into a private member. Use the `scrolled` method instead."
+            },
+            {
+              "name": "breaking-change",
+              "comment": "13.0.0"
+            }
+          ]
+        },
+        {
+          "name": "registerDropContainer",
+          "signatures": [
+            {
+              "name": "registerDropContainer",
+              "entryType": "function",
+              "description": "Adds a drop container to the registry.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "drop",
+                  "description": "",
+                  "type": "DropListRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Adds a drop container to the registry. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "drop",
+                "description": "",
+                "type": "DropListRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "registerDropContainer",
+            "description": "Adds a drop container to the registry.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Adds a drop container to the registry. */"
+          },
+          "entryType": "function",
+          "description": "Adds a drop container to the registry.",
+          "jsdocTags": [],
+          "rawComment": "/** Adds a drop container to the registry. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "registerDragItem",
+          "signatures": [
+            {
+              "name": "registerDragItem",
+              "entryType": "function",
+              "description": "Adds a drag item instance to the registry.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "drag",
+                  "description": "",
+                  "type": "DragRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Adds a drag item instance to the registry. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "drag",
+                "description": "",
+                "type": "DragRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "registerDragItem",
+            "description": "Adds a drag item instance to the registry.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Adds a drag item instance to the registry. */"
+          },
+          "entryType": "function",
+          "description": "Adds a drag item instance to the registry.",
+          "jsdocTags": [],
+          "rawComment": "/** Adds a drag item instance to the registry. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "removeDropContainer",
+          "signatures": [
+            {
+              "name": "removeDropContainer",
+              "entryType": "function",
+              "description": "Removes a drop container from the registry.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "drop",
+                  "description": "",
+                  "type": "DropListRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Removes a drop container from the registry. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "drop",
+                "description": "",
+                "type": "DropListRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "removeDropContainer",
+            "description": "Removes a drop container from the registry.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Removes a drop container from the registry. */"
+          },
+          "entryType": "function",
+          "description": "Removes a drop container from the registry.",
+          "jsdocTags": [],
+          "rawComment": "/** Removes a drop container from the registry. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "removeDragItem",
+          "signatures": [
+            {
+              "name": "removeDragItem",
+              "entryType": "function",
+              "description": "Removes a drag item instance from the registry.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "drag",
+                  "description": "",
+                  "type": "DragRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Removes a drag item instance from the registry. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "drag",
+                "description": "",
+                "type": "DragRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "removeDragItem",
+            "description": "Removes a drag item instance from the registry.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Removes a drag item instance from the registry. */"
+          },
+          "entryType": "function",
+          "description": "Removes a drag item instance from the registry.",
+          "jsdocTags": [],
+          "rawComment": "/** Removes a drag item instance from the registry. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "startDragging",
+          "signatures": [
+            {
+              "name": "startDragging",
+              "entryType": "function",
+              "description": "Starts the dragging sequence for a drag instance.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Drag instance which is being dragged."
+                },
+                {
+                  "name": "param",
+                  "comment": "Event that initiated the dragging."
+                }
+              ],
+              "params": [
+                {
+                  "name": "drag",
+                  "description": "Drag instance which is being dragged.",
+                  "type": "DragRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "event",
+                  "description": "Event that initiated the dragging.",
+                  "type": "MouseEvent | TouchEvent",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Starts the dragging sequence for a drag instance.\n   * @param drag Drag instance which is being dragged.\n   * @param event Event that initiated the dragging.\n   */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "drag",
+                "description": "Drag instance which is being dragged.",
+                "type": "DragRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "event",
+                "description": "Event that initiated the dragging.",
+                "type": "MouseEvent | TouchEvent",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "startDragging",
+            "description": "Starts the dragging sequence for a drag instance.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Drag instance which is being dragged."
+              },
+              {
+                "name": "param",
+                "comment": "Event that initiated the dragging."
+              }
+            ],
+            "rawComment": "/**\n   * Starts the dragging sequence for a drag instance.\n   * @param drag Drag instance which is being dragged.\n   * @param event Event that initiated the dragging.\n   */"
+          },
+          "entryType": "function",
+          "description": "Starts the dragging sequence for a drag instance.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Drag instance which is being dragged."
+            },
+            {
+              "name": "param",
+              "comment": "Event that initiated the dragging."
+            }
+          ],
+          "rawComment": "/**\n   * Starts the dragging sequence for a drag instance.\n   * @param drag Drag instance which is being dragged.\n   * @param event Event that initiated the dragging.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "stopDragging",
+          "signatures": [
+            {
+              "name": "stopDragging",
+              "entryType": "function",
+              "description": "Stops dragging a drag item instance.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "drag",
+                  "description": "",
+                  "type": "DragRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Stops dragging a drag item instance. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "drag",
+                "description": "",
+                "type": "DragRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "stopDragging",
+            "description": "Stops dragging a drag item instance.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Stops dragging a drag item instance. */"
+          },
+          "entryType": "function",
+          "description": "Stops dragging a drag item instance.",
+          "jsdocTags": [],
+          "rawComment": "/** Stops dragging a drag item instance. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "isDragging",
+          "signatures": [
+            {
+              "name": "isDragging",
+              "entryType": "function",
+              "description": "Gets whether a drag item instance is currently being dragged.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "drag",
+                  "description": "",
+                  "type": "DragRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Gets whether a drag item instance is currently being dragged. */",
+              "returnType": "boolean"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "drag",
+                "description": "",
+                "type": "DragRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "boolean",
+            "generics": [],
+            "name": "isDragging",
+            "description": "Gets whether a drag item instance is currently being dragged.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets whether a drag item instance is currently being dragged. */"
+          },
+          "entryType": "function",
+          "description": "Gets whether a drag item instance is currently being dragged.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets whether a drag item instance is currently being dragged. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "scrolled",
+          "signatures": [
+            {
+              "name": "scrolled",
+              "entryType": "function",
+              "description": "Gets a stream that will emit when any element on the page is scrolled while an item is being\ndragged.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Optional shadow root that the current dragging sequence started from.\nTop-level listeners won't pick up events coming from the shadow DOM so this parameter can\nbe used to include an additional top-level listener at the shadow root level."
+                }
+              ],
+              "params": [
+                {
+                  "name": "shadowRoot",
+                  "description": "Optional shadow root that the current dragging sequence started from.\nTop-level listeners won't pick up events coming from the shadow DOM so this parameter can\nbe used to include an additional top-level listener at the shadow root level.",
+                  "type": "DocumentOrShadowRoot | null | undefined",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Gets a stream that will emit when any element on the page is scrolled while an item is being\n   * dragged.\n   * @param shadowRoot Optional shadow root that the current dragging sequence started from.\n   *   Top-level listeners won't pick up events coming from the shadow DOM so this parameter can\n   *   be used to include an additional top-level listener at the shadow root level.\n   */",
+              "returnType": "Observable<Event>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "shadowRoot",
+                "description": "Optional shadow root that the current dragging sequence started from.\nTop-level listeners won't pick up events coming from the shadow DOM so this parameter can\nbe used to include an additional top-level listener at the shadow root level.",
+                "type": "DocumentOrShadowRoot | null | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Observable<Event>",
+            "generics": [],
+            "name": "scrolled",
+            "description": "Gets a stream that will emit when any element on the page is scrolled while an item is being\ndragged.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Optional shadow root that the current dragging sequence started from.\nTop-level listeners won't pick up events coming from the shadow DOM so this parameter can\nbe used to include an additional top-level listener at the shadow root level."
+              }
+            ],
+            "rawComment": "/**\n   * Gets a stream that will emit when any element on the page is scrolled while an item is being\n   * dragged.\n   * @param shadowRoot Optional shadow root that the current dragging sequence started from.\n   *   Top-level listeners won't pick up events coming from the shadow DOM so this parameter can\n   *   be used to include an additional top-level listener at the shadow root level.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets a stream that will emit when any element on the page is scrolled while an item is being\ndragged.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Optional shadow root that the current dragging sequence started from.\nTop-level listeners won't pick up events coming from the shadow DOM so this parameter can\nbe used to include an additional top-level listener at the shadow root level."
+            }
+          ],
+          "rawComment": "/**\n   * Gets a stream that will emit when any element on the page is scrolled while an item is being\n   * dragged.\n   * @param shadowRoot Optional shadow root that the current dragging sequence started from.\n   *   Top-level listeners won't pick up events coming from the shadow DOM so this parameter can\n   *   be used to include an additional top-level listener at the shadow root level.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "registerDirectiveNode",
+          "signatures": [
+            {
+              "name": "registerDirectiveNode",
+              "entryType": "function",
+              "description": "Tracks the DOM node which has a draggable directive.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Node to track."
+                },
+                {
+                  "name": "param",
+                  "comment": "Drag directive set on the node."
+                }
+              ],
+              "params": [
+                {
+                  "name": "node",
+                  "description": "Node to track.",
+                  "type": "Node",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "dragRef",
+                  "description": "Drag directive set on the node.",
+                  "type": "CdkDrag<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Tracks the DOM node which has a draggable directive.\n   * @param node Node to track.\n   * @param dragRef Drag directive set on the node.\n   */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "node",
+                "description": "Node to track.",
+                "type": "Node",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "dragRef",
+                "description": "Drag directive set on the node.",
+                "type": "CdkDrag<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "registerDirectiveNode",
+            "description": "Tracks the DOM node which has a draggable directive.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Node to track."
+              },
+              {
+                "name": "param",
+                "comment": "Drag directive set on the node."
+              }
+            ],
+            "rawComment": "/**\n   * Tracks the DOM node which has a draggable directive.\n   * @param node Node to track.\n   * @param dragRef Drag directive set on the node.\n   */"
+          },
+          "entryType": "function",
+          "description": "Tracks the DOM node which has a draggable directive.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Node to track."
+            },
+            {
+              "name": "param",
+              "comment": "Drag directive set on the node."
+            }
+          ],
+          "rawComment": "/**\n   * Tracks the DOM node which has a draggable directive.\n   * @param node Node to track.\n   * @param dragRef Drag directive set on the node.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "removeDirectiveNode",
+          "signatures": [
+            {
+              "name": "removeDirectiveNode",
+              "entryType": "function",
+              "description": "Stops tracking a draggable directive node.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Node to stop tracking."
+                }
+              ],
+              "params": [
+                {
+                  "name": "node",
+                  "description": "Node to stop tracking.",
+                  "type": "Node",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Stops tracking a draggable directive node.\n   * @param node Node to stop tracking.\n   */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "node",
+                "description": "Node to stop tracking.",
+                "type": "Node",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "removeDirectiveNode",
+            "description": "Stops tracking a draggable directive node.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Node to stop tracking."
+              }
+            ],
+            "rawComment": "/**\n   * Stops tracking a draggable directive node.\n   * @param node Node to stop tracking.\n   */"
+          },
+          "entryType": "function",
+          "description": "Stops tracking a draggable directive node.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Node to stop tracking."
+            }
+          ],
+          "rawComment": "/**\n   * Stops tracking a draggable directive node.\n   * @param node Node to stop tracking.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getDragDirectiveForNode",
+          "signatures": [
+            {
+              "name": "getDragDirectiveForNode",
+              "entryType": "function",
+              "description": "Gets the drag directive corresponding to a specific DOM node, if any.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Node for which to do the lookup."
+                }
+              ],
+              "params": [
+                {
+                  "name": "node",
+                  "description": "Node for which to do the lookup.",
+                  "type": "Node",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Gets the drag directive corresponding to a specific DOM node, if any.\n   * @param node Node for which to do the lookup.\n   */",
+              "returnType": "CdkDrag<any> | null"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "node",
+                "description": "Node for which to do the lookup.",
+                "type": "Node",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "CdkDrag<any> | null",
+            "generics": [],
+            "name": "getDragDirectiveForNode",
+            "description": "Gets the drag directive corresponding to a specific DOM node, if any.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Node for which to do the lookup."
+              }
+            ],
+            "rawComment": "/**\n   * Gets the drag directive corresponding to a specific DOM node, if any.\n   * @param node Node for which to do the lookup.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets the drag directive corresponding to a specific DOM node, if any.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Node for which to do the lookup."
+            }
+          ],
+          "rawComment": "/**\n   * Gets the drag directive corresponding to a specific DOM node, if any.\n   * @param node Node for which to do the lookup.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "ngOnDestroy",
+          "signatures": [
+            {
+              "name": "ngOnDestroy",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "ngOnDestroy",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "_",
+          "default": "unknown"
+        },
+        {
+          "name": "__",
+          "default": "unknown"
+        }
+      ],
+      "description": "Service that keeps track of all the drag item and drop container\ninstances, and manages global event listeners on the `document`.",
+      "jsdocTags": [
+        {
+          "name": "docs-private",
+          "comment": ""
+        }
+      ],
+      "rawComment": "/**\n * Service that keeps track of all the drag item and drop container\n * instances, and manages global event listeners on the `document`.\n * @docs-private\n */",
+      "implements": [
+        "OnDestroy"
+      ],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-drop-registry.ts",
+        "startLine": 59,
+        "endLine": 344
+      }
+    },
+    {
+      "name": "CdkDragEnter",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "container",
+          "type": "CdkDropList<T>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Container into which the user has moved the item.",
+          "jsdocTags": []
+        },
+        {
+          "name": "item",
+          "type": "CdkDrag<I>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Item that was moved into the container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "currentIndex",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Index at which the item has entered the container.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        },
+        {
+          "name": "I",
+          "default": "T"
+        }
+      ],
+      "description": "Event emitted when the user moves an item into a new drop container.",
+      "jsdocTags": [],
+      "rawComment": "/** Event emitted when the user moves an item into a new drop container. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-events.ts",
+        "startLine": 41,
+        "endLine": 48
+      }
+    },
+    {
+      "name": "copyArrayItem",
+      "signatures": [
+        {
+          "name": "copyArrayItem",
+          "entryType": "function",
+          "description": "Copies an item from one array to another, leaving it in its\noriginal position in current array.",
+          "generics": [
+            {
+              "name": "T",
+              "default": "any"
+            }
+          ],
+          "isNewType": false,
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Array from which to copy the item."
+            },
+            {
+              "name": "param",
+              "comment": "Array into which is copy the item."
+            },
+            {
+              "name": "param",
+              "comment": "Index of the item in its current array."
+            },
+            {
+              "name": "param",
+              "comment": "Index at which to insert the item."
+            }
+          ],
+          "params": [
+            {
+              "name": "currentArray",
+              "description": "Array from which to copy the item.",
+              "type": "T[]",
+              "isOptional": false,
+              "isRestParam": false
+            },
+            {
+              "name": "targetArray",
+              "description": "Array into which is copy the item.",
+              "type": "T[]",
+              "isOptional": false,
+              "isRestParam": false
+            },
+            {
+              "name": "currentIndex",
+              "description": "Index of the item in its current array.",
+              "type": "number",
+              "isOptional": false,
+              "isRestParam": false
+            },
+            {
+              "name": "targetIndex",
+              "description": "Index at which to insert the item.",
+              "type": "number",
+              "isOptional": false,
+              "isRestParam": false
+            }
+          ],
+          "rawComment": "/**\n * Copies an item from one array to another, leaving it in its\n * original position in current array.\n * @param currentArray Array from which to copy the item.\n * @param targetArray Array into which is copy the item.\n * @param currentIndex Index of the item in its current array.\n * @param targetIndex Index at which to insert the item.\n *\n */",
+          "returnType": "void"
+        }
+      ],
+      "implementation": {
+        "params": [
+          {
+            "name": "currentArray",
+            "description": "Array from which to copy the item.",
+            "type": "T[]",
+            "isOptional": false,
+            "isRestParam": false
+          },
+          {
+            "name": "targetArray",
+            "description": "Array into which is copy the item.",
+            "type": "T[]",
+            "isOptional": false,
+            "isRestParam": false
+          },
+          {
+            "name": "currentIndex",
+            "description": "Index of the item in its current array.",
+            "type": "number",
+            "isOptional": false,
+            "isRestParam": false
+          },
+          {
+            "name": "targetIndex",
+            "description": "Index at which to insert the item.",
+            "type": "number",
+            "isOptional": false,
+            "isRestParam": false
+          }
+        ],
+        "isNewType": false,
+        "returnType": "void",
+        "generics": [
+          {
+            "name": "T",
+            "default": "any"
+          }
+        ],
+        "name": "copyArrayItem",
+        "description": "Copies an item from one array to another, leaving it in its\noriginal position in current array.",
+        "entryType": "function",
+        "jsdocTags": [
+          {
+            "name": "param",
+            "comment": "Array from which to copy the item."
+          },
+          {
+            "name": "param",
+            "comment": "Array into which is copy the item."
+          },
+          {
+            "name": "param",
+            "comment": "Index of the item in its current array."
+          },
+          {
+            "name": "param",
+            "comment": "Index at which to insert the item."
+          }
+        ],
+        "rawComment": "/**\n * Copies an item from one array to another, leaving it in its\n * original position in current array.\n * @param currentArray Array from which to copy the item.\n * @param targetArray Array into which is copy the item.\n * @param currentIndex Index of the item in its current array.\n * @param targetIndex Index at which to insert the item.\n *\n */"
+      },
+      "entryType": "function",
+      "description": "Copies an item from one array to another, leaving it in its\noriginal position in current array.",
+      "jsdocTags": [
+        {
+          "name": "param",
+          "comment": "Array from which to copy the item."
+        },
+        {
+          "name": "param",
+          "comment": "Array into which is copy the item."
+        },
+        {
+          "name": "param",
+          "comment": "Index of the item in its current array."
+        },
+        {
+          "name": "param",
+          "comment": "Index at which to insert the item."
+        }
+      ],
+      "rawComment": "/**\n * Copies an item from one array to another, leaving it in its\n * original position in current array.\n * @param currentArray Array from which to copy the item.\n * @param targetArray Array into which is copy the item.\n * @param currentIndex Index of the item in its current array.\n * @param targetIndex Index at which to insert the item.\n *\n */",
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-utils.ts",
+        "startLine": 63,
+        "endLine": 74
+      }
+    },
+    {
+      "name": "CdkDragExit",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "container",
+          "type": "CdkDropList<T>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Container from which the user has a removed an item.",
+          "jsdocTags": []
+        },
+        {
+          "name": "item",
+          "type": "CdkDrag<I>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Item that was removed from the container.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        },
+        {
+          "name": "I",
+          "default": "T"
+        }
+      ],
+      "description": "Event emitted when the user removes an item from a\ndrop container by moving it into another one.",
+      "jsdocTags": [],
+      "rawComment": "/**\n * Event emitted when the user removes an item from a\n * drop container by moving it into another one.\n */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-events.ts",
+        "startLine": 54,
+        "endLine": 59
+      }
+    },
+    {
+      "name": "DropListRef",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "any",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_dragDropRegistry",
+                "description": "",
+                "type": "DragDropRegistry<unknown, unknown>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_document",
+                "description": "",
+                "type": "any",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_ngZone",
+                "description": "",
+                "type": "NgZone",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_viewportRuler",
+                "description": "",
+                "type": "ViewportRuler",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "DropListRef<T>",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "element",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Element that the drop list is attached to.",
+          "jsdocTags": []
+        },
+        {
+          "name": "disabled",
+          "type": "boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Whether starting a dragging sequence from this container is disabled.",
+          "jsdocTags": []
+        },
+        {
+          "name": "sortingDisabled",
+          "type": "boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Whether sorting items within the list is disabled.",
+          "jsdocTags": []
+        },
+        {
+          "name": "lockAxis",
+          "type": "\"x\" | \"y\"",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Locks the position of the draggable elements inside the container along the specified axis.",
+          "jsdocTags": []
+        },
+        {
+          "name": "autoScrollDisabled",
+          "type": "boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Whether auto-scrolling the view when the user\nmoves their pointer close to the edges is disabled.",
+          "jsdocTags": []
+        },
+        {
+          "name": "autoScrollStep",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Number of pixels to scroll for each frame when auto-scrolling an element.",
+          "jsdocTags": []
+        },
+        {
+          "name": "enterPredicate",
+          "type": "(drag: DragRef<any>, drop: DropListRef<any>) => boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Function that is used to determine whether an item\nis allowed to be moved into a drop container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "sortPredicate",
+          "type": "(index: number, drag: DragRef<any>, drop: DropListRef<any>) => boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Function that is used to determine whether an item can be sorted into a particular index.",
+          "jsdocTags": []
+        },
+        {
+          "name": "beforeStarted",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits right before dragging has started.",
+          "jsdocTags": []
+        },
+        {
+          "name": "entered",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user has moved a new drag item into this container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "exited",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user removes an item from the container\nby dragging it into another container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "dropped",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user drops an item inside the container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "sorted",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits as the user is swapping items while actively dragging.",
+          "jsdocTags": []
+        },
+        {
+          "name": "receivingStarted",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when a dragging sequence is started in a list connected to the current one.",
+          "jsdocTags": []
+        },
+        {
+          "name": "receivingStopped",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when a dragging sequence is stopped from a list connected to the current one.",
+          "jsdocTags": []
+        },
+        {
+          "name": "data",
+          "type": "T",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Arbitrary data that can be attached to the drop list.",
+          "jsdocTags": []
+        },
+        {
+          "name": "dispose",
+          "signatures": [
+            {
+              "name": "dispose",
+              "entryType": "function",
+              "description": "Removes the drop list functionality from the DOM element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Removes the drop list functionality from the DOM element. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "dispose",
+            "description": "Removes the drop list functionality from the DOM element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Removes the drop list functionality from the DOM element. */"
+          },
+          "entryType": "function",
+          "description": "Removes the drop list functionality from the DOM element.",
+          "jsdocTags": [],
+          "rawComment": "/** Removes the drop list functionality from the DOM element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "isDragging",
+          "signatures": [
+            {
+              "name": "isDragging",
+              "entryType": "function",
+              "description": "Whether an item from this list is currently being dragged.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Whether an item from this list is currently being dragged. */",
+              "returnType": "boolean"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "boolean",
+            "generics": [],
+            "name": "isDragging",
+            "description": "Whether an item from this list is currently being dragged.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Whether an item from this list is currently being dragged. */"
+          },
+          "entryType": "function",
+          "description": "Whether an item from this list is currently being dragged.",
+          "jsdocTags": [],
+          "rawComment": "/** Whether an item from this list is currently being dragged. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "start",
+          "signatures": [
+            {
+              "name": "start",
+              "entryType": "function",
+              "description": "Starts dragging an item.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Starts dragging an item. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "start",
+            "description": "Starts dragging an item.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Starts dragging an item. */"
+          },
+          "entryType": "function",
+          "description": "Starts dragging an item.",
+          "jsdocTags": [],
+          "rawComment": "/** Starts dragging an item. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "enter",
+          "signatures": [
+            {
+              "name": "enter",
+              "entryType": "function",
+              "description": "Attempts to move an item into the container.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Item that was moved into the container."
+                },
+                {
+                  "name": "param",
+                  "comment": "Position of the item along the X axis."
+                },
+                {
+                  "name": "param",
+                  "comment": "Position of the item along the Y axis."
+                },
+                {
+                  "name": "param",
+                  "comment": "Index at which the item entered. If omitted, the container will try to figure it\nout automatically."
+                }
+              ],
+              "params": [
+                {
+                  "name": "item",
+                  "description": "Item that was moved into the container.",
+                  "type": "DragRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "pointerX",
+                  "description": "Position of the item along the X axis.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "pointerY",
+                  "description": "Position of the item along the Y axis.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "index",
+                  "description": "Index at which the item entered. If omitted, the container will try to figure it\nout automatically.",
+                  "type": "number | undefined",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Attempts to move an item into the container.\n   * @param item Item that was moved into the container.\n   * @param pointerX Position of the item along the X axis.\n   * @param pointerY Position of the item along the Y axis.\n   * @param index Index at which the item entered. If omitted, the container will try to figure it\n   *   out automatically.\n   */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "item",
+                "description": "Item that was moved into the container.",
+                "type": "DragRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "pointerX",
+                "description": "Position of the item along the X axis.",
+                "type": "number",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "pointerY",
+                "description": "Position of the item along the Y axis.",
+                "type": "number",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "index",
+                "description": "Index at which the item entered. If omitted, the container will try to figure it\nout automatically.",
+                "type": "number | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "enter",
+            "description": "Attempts to move an item into the container.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Item that was moved into the container."
+              },
+              {
+                "name": "param",
+                "comment": "Position of the item along the X axis."
+              },
+              {
+                "name": "param",
+                "comment": "Position of the item along the Y axis."
+              },
+              {
+                "name": "param",
+                "comment": "Index at which the item entered. If omitted, the container will try to figure it\nout automatically."
+              }
+            ],
+            "rawComment": "/**\n   * Attempts to move an item into the container.\n   * @param item Item that was moved into the container.\n   * @param pointerX Position of the item along the X axis.\n   * @param pointerY Position of the item along the Y axis.\n   * @param index Index at which the item entered. If omitted, the container will try to figure it\n   *   out automatically.\n   */"
+          },
+          "entryType": "function",
+          "description": "Attempts to move an item into the container.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Item that was moved into the container."
+            },
+            {
+              "name": "param",
+              "comment": "Position of the item along the X axis."
+            },
+            {
+              "name": "param",
+              "comment": "Position of the item along the Y axis."
+            },
+            {
+              "name": "param",
+              "comment": "Index at which the item entered. If omitted, the container will try to figure it\nout automatically."
+            }
+          ],
+          "rawComment": "/**\n   * Attempts to move an item into the container.\n   * @param item Item that was moved into the container.\n   * @param pointerX Position of the item along the X axis.\n   * @param pointerY Position of the item along the Y axis.\n   * @param index Index at which the item entered. If omitted, the container will try to figure it\n   *   out automatically.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "exit",
+          "signatures": [
+            {
+              "name": "exit",
+              "entryType": "function",
+              "description": "Removes an item from the container after it was dragged into another container by the user.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Item that was dragged out."
+                }
+              ],
+              "params": [
+                {
+                  "name": "item",
+                  "description": "Item that was dragged out.",
+                  "type": "DragRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Removes an item from the container after it was dragged into another container by the user.\n   * @param item Item that was dragged out.\n   */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "item",
+                "description": "Item that was dragged out.",
+                "type": "DragRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "exit",
+            "description": "Removes an item from the container after it was dragged into another container by the user.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Item that was dragged out."
+              }
+            ],
+            "rawComment": "/**\n   * Removes an item from the container after it was dragged into another container by the user.\n   * @param item Item that was dragged out.\n   */"
+          },
+          "entryType": "function",
+          "description": "Removes an item from the container after it was dragged into another container by the user.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Item that was dragged out."
+            }
+          ],
+          "rawComment": "/**\n   * Removes an item from the container after it was dragged into another container by the user.\n   * @param item Item that was dragged out.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "drop",
+          "signatures": [
+            {
+              "name": "drop",
+              "entryType": "function",
+              "description": "Drops an item into this container.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Item being dropped into the container."
+                },
+                {
+                  "name": "param",
+                  "comment": "Index at which the item should be inserted."
+                },
+                {
+                  "name": "param",
+                  "comment": "Index of the item when dragging started."
+                },
+                {
+                  "name": "param",
+                  "comment": "Container from which the item got dragged in."
+                },
+                {
+                  "name": "param",
+                  "comment": "Whether the user's pointer was over the\ncontainer when the item was dropped."
+                },
+                {
+                  "name": "param",
+                  "comment": "Distance the user has dragged since the start of the dragging sequence."
+                },
+                {
+                  "name": "param",
+                  "comment": "Event that triggered the dropping sequence."
+                },
+                {
+                  "name": "breaking-change",
+                  "comment": "15.0.0 `previousIndex` and `event` parameters to become required."
+                }
+              ],
+              "params": [
+                {
+                  "name": "item",
+                  "description": "Item being dropped into the container.",
+                  "type": "DragRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "currentIndex",
+                  "description": "Index at which the item should be inserted.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "previousIndex",
+                  "description": "Index of the item when dragging started.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "previousContainer",
+                  "description": "Container from which the item got dragged in.",
+                  "type": "DropListRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "isPointerOverContainer",
+                  "description": "Whether the user's pointer was over the\ncontainer when the item was dropped.",
+                  "type": "boolean",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "distance",
+                  "description": "Distance the user has dragged since the start of the dragging sequence.",
+                  "type": "Point",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "dropPoint",
+                  "description": "",
+                  "type": "Point",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "event",
+                  "description": "Event that triggered the dropping sequence.",
+                  "type": "MouseEvent | TouchEvent",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Drops an item into this container.\n   * @param item Item being dropped into the container.\n   * @param currentIndex Index at which the item should be inserted.\n   * @param previousIndex Index of the item when dragging started.\n   * @param previousContainer Container from which the item got dragged in.\n   * @param isPointerOverContainer Whether the user's pointer was over the\n   *    container when the item was dropped.\n   * @param distance Distance the user has dragged since the start of the dragging sequence.\n   * @param event Event that triggered the dropping sequence.\n   *\n   * @breaking-change 15.0.0 `previousIndex` and `event` parameters to become required.\n   */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "item",
+                "description": "Item being dropped into the container.",
+                "type": "DragRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "currentIndex",
+                "description": "Index at which the item should be inserted.",
+                "type": "number",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "previousIndex",
+                "description": "Index of the item when dragging started.",
+                "type": "number",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "previousContainer",
+                "description": "Container from which the item got dragged in.",
+                "type": "DropListRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "isPointerOverContainer",
+                "description": "Whether the user's pointer was over the\ncontainer when the item was dropped.",
+                "type": "boolean",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "distance",
+                "description": "Distance the user has dragged since the start of the dragging sequence.",
+                "type": "Point",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "dropPoint",
+                "description": "",
+                "type": "Point",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "event",
+                "description": "Event that triggered the dropping sequence.",
+                "type": "MouseEvent | TouchEvent",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "drop",
+            "description": "Drops an item into this container.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Item being dropped into the container."
+              },
+              {
+                "name": "param",
+                "comment": "Index at which the item should be inserted."
+              },
+              {
+                "name": "param",
+                "comment": "Index of the item when dragging started."
+              },
+              {
+                "name": "param",
+                "comment": "Container from which the item got dragged in."
+              },
+              {
+                "name": "param",
+                "comment": "Whether the user's pointer was over the\ncontainer when the item was dropped."
+              },
+              {
+                "name": "param",
+                "comment": "Distance the user has dragged since the start of the dragging sequence."
+              },
+              {
+                "name": "param",
+                "comment": "Event that triggered the dropping sequence."
+              },
+              {
+                "name": "breaking-change",
+                "comment": "15.0.0 `previousIndex` and `event` parameters to become required."
+              }
+            ],
+            "rawComment": "/**\n   * Drops an item into this container.\n   * @param item Item being dropped into the container.\n   * @param currentIndex Index at which the item should be inserted.\n   * @param previousIndex Index of the item when dragging started.\n   * @param previousContainer Container from which the item got dragged in.\n   * @param isPointerOverContainer Whether the user's pointer was over the\n   *    container when the item was dropped.\n   * @param distance Distance the user has dragged since the start of the dragging sequence.\n   * @param event Event that triggered the dropping sequence.\n   *\n   * @breaking-change 15.0.0 `previousIndex` and `event` parameters to become required.\n   */"
+          },
+          "entryType": "function",
+          "description": "Drops an item into this container.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Item being dropped into the container."
+            },
+            {
+              "name": "param",
+              "comment": "Index at which the item should be inserted."
+            },
+            {
+              "name": "param",
+              "comment": "Index of the item when dragging started."
+            },
+            {
+              "name": "param",
+              "comment": "Container from which the item got dragged in."
+            },
+            {
+              "name": "param",
+              "comment": "Whether the user's pointer was over the\ncontainer when the item was dropped."
+            },
+            {
+              "name": "param",
+              "comment": "Distance the user has dragged since the start of the dragging sequence."
+            },
+            {
+              "name": "param",
+              "comment": "Event that triggered the dropping sequence."
+            },
+            {
+              "name": "breaking-change",
+              "comment": "15.0.0 `previousIndex` and `event` parameters to become required."
+            }
+          ],
+          "rawComment": "/**\n   * Drops an item into this container.\n   * @param item Item being dropped into the container.\n   * @param currentIndex Index at which the item should be inserted.\n   * @param previousIndex Index of the item when dragging started.\n   * @param previousContainer Container from which the item got dragged in.\n   * @param isPointerOverContainer Whether the user's pointer was over the\n   *    container when the item was dropped.\n   * @param distance Distance the user has dragged since the start of the dragging sequence.\n   * @param event Event that triggered the dropping sequence.\n   *\n   * @breaking-change 15.0.0 `previousIndex` and `event` parameters to become required.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withItems",
+          "signatures": [
+            {
+              "name": "withItems",
+              "entryType": "function",
+              "description": "Sets the draggable items that are a part of this list.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Items that are a part of this list."
+                }
+              ],
+              "params": [
+                {
+                  "name": "items",
+                  "description": "Items that are a part of this list.",
+                  "type": "DragRef<any>[]",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets the draggable items that are a part of this list.\n   * @param items Items that are a part of this list.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "items",
+                "description": "Items that are a part of this list.",
+                "type": "DragRef<any>[]",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withItems",
+            "description": "Sets the draggable items that are a part of this list.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Items that are a part of this list."
+              }
+            ],
+            "rawComment": "/**\n   * Sets the draggable items that are a part of this list.\n   * @param items Items that are a part of this list.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets the draggable items that are a part of this list.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Items that are a part of this list."
+            }
+          ],
+          "rawComment": "/**\n   * Sets the draggable items that are a part of this list.\n   * @param items Items that are a part of this list.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withDirection",
+          "signatures": [
+            {
+              "name": "withDirection",
+              "entryType": "function",
+              "description": "Sets the layout direction of the drop list.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "direction",
+                  "description": "",
+                  "type": "Direction",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Sets the layout direction of the drop list. */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "direction",
+                "description": "",
+                "type": "Direction",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withDirection",
+            "description": "Sets the layout direction of the drop list.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Sets the layout direction of the drop list. */"
+          },
+          "entryType": "function",
+          "description": "Sets the layout direction of the drop list.",
+          "jsdocTags": [],
+          "rawComment": "/** Sets the layout direction of the drop list. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "connectedTo",
+          "signatures": [
+            {
+              "name": "connectedTo",
+              "entryType": "function",
+              "description": "Sets the containers that are connected to this one. When two or more containers are\nconnected, the user will be allowed to transfer items between them.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Other containers that the current containers should be connected to."
+                }
+              ],
+              "params": [
+                {
+                  "name": "connectedTo",
+                  "description": "Other containers that the current containers should be connected to.",
+                  "type": "DropListRef<any>[]",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets the containers that are connected to this one. When two or more containers are\n   * connected, the user will be allowed to transfer items between them.\n   * @param connectedTo Other containers that the current containers should be connected to.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "connectedTo",
+                "description": "Other containers that the current containers should be connected to.",
+                "type": "DropListRef<any>[]",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "connectedTo",
+            "description": "Sets the containers that are connected to this one. When two or more containers are\nconnected, the user will be allowed to transfer items between them.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Other containers that the current containers should be connected to."
+              }
+            ],
+            "rawComment": "/**\n   * Sets the containers that are connected to this one. When two or more containers are\n   * connected, the user will be allowed to transfer items between them.\n   * @param connectedTo Other containers that the current containers should be connected to.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets the containers that are connected to this one. When two or more containers are\nconnected, the user will be allowed to transfer items between them.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Other containers that the current containers should be connected to."
+            }
+          ],
+          "rawComment": "/**\n   * Sets the containers that are connected to this one. When two or more containers are\n   * connected, the user will be allowed to transfer items between them.\n   * @param connectedTo Other containers that the current containers should be connected to.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withOrientation",
+          "signatures": [
+            {
+              "name": "withOrientation",
+              "entryType": "function",
+              "description": "Sets the orientation of the container.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "New orientation for the container."
+                }
+              ],
+              "params": [
+                {
+                  "name": "orientation",
+                  "description": "New orientation for the container.",
+                  "type": "DropListOrientation",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets the orientation of the container.\n   * @param orientation New orientation for the container.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "orientation",
+                "description": "New orientation for the container.",
+                "type": "DropListOrientation",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withOrientation",
+            "description": "Sets the orientation of the container.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "New orientation for the container."
+              }
+            ],
+            "rawComment": "/**\n   * Sets the orientation of the container.\n   * @param orientation New orientation for the container.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets the orientation of the container.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "New orientation for the container."
+            }
+          ],
+          "rawComment": "/**\n   * Sets the orientation of the container.\n   * @param orientation New orientation for the container.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withScrollableParents",
+          "signatures": [
+            {
+              "name": "withScrollableParents",
+              "entryType": "function",
+              "description": "Sets which parent elements are can be scrolled while the user is dragging.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Elements that can be scrolled."
+                }
+              ],
+              "params": [
+                {
+                  "name": "elements",
+                  "description": "Elements that can be scrolled.",
+                  "type": "HTMLElement[]",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets which parent elements are can be scrolled while the user is dragging.\n   * @param elements Elements that can be scrolled.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "elements",
+                "description": "Elements that can be scrolled.",
+                "type": "HTMLElement[]",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withScrollableParents",
+            "description": "Sets which parent elements are can be scrolled while the user is dragging.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Elements that can be scrolled."
+              }
+            ],
+            "rawComment": "/**\n   * Sets which parent elements are can be scrolled while the user is dragging.\n   * @param elements Elements that can be scrolled.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets which parent elements are can be scrolled while the user is dragging.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Elements that can be scrolled."
+            }
+          ],
+          "rawComment": "/**\n   * Sets which parent elements are can be scrolled while the user is dragging.\n   * @param elements Elements that can be scrolled.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withElementContainer",
+          "signatures": [
+            {
+              "name": "withElementContainer",
+              "entryType": "function",
+              "description": "Configures the drop list so that a different element is used as the container for the\ndragged items. This is useful for the cases when one might not have control over the\nfull DOM that sets up the dragging.\nNote that the alternate container needs to be a descendant of the drop list.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "New element container to be assigned."
+                }
+              ],
+              "params": [
+                {
+                  "name": "container",
+                  "description": "New element container to be assigned.",
+                  "type": "HTMLElement",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Configures the drop list so that a different element is used as the container for the\n   * dragged items. This is useful for the cases when one might not have control over the\n   * full DOM that sets up the dragging.\n   * Note that the alternate container needs to be a descendant of the drop list.\n   * @param container New element container to be assigned.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "container",
+                "description": "New element container to be assigned.",
+                "type": "HTMLElement",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withElementContainer",
+            "description": "Configures the drop list so that a different element is used as the container for the\ndragged items. This is useful for the cases when one might not have control over the\nfull DOM that sets up the dragging.\nNote that the alternate container needs to be a descendant of the drop list.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "New element container to be assigned."
+              }
+            ],
+            "rawComment": "/**\n   * Configures the drop list so that a different element is used as the container for the\n   * dragged items. This is useful for the cases when one might not have control over the\n   * full DOM that sets up the dragging.\n   * Note that the alternate container needs to be a descendant of the drop list.\n   * @param container New element container to be assigned.\n   */"
+          },
+          "entryType": "function",
+          "description": "Configures the drop list so that a different element is used as the container for the\ndragged items. This is useful for the cases when one might not have control over the\nfull DOM that sets up the dragging.\nNote that the alternate container needs to be a descendant of the drop list.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "New element container to be assigned."
+            }
+          ],
+          "rawComment": "/**\n   * Configures the drop list so that a different element is used as the container for the\n   * dragged items. This is useful for the cases when one might not have control over the\n   * full DOM that sets up the dragging.\n   * Note that the alternate container needs to be a descendant of the drop list.\n   * @param container New element container to be assigned.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getScrollableParents",
+          "signatures": [
+            {
+              "name": "getScrollableParents",
+              "entryType": "function",
+              "description": "Gets the scrollable parents that are registered with this drop container.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Gets the scrollable parents that are registered with this drop container. */",
+              "returnType": "readonly HTMLElement[]"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "readonly HTMLElement[]",
+            "generics": [],
+            "name": "getScrollableParents",
+            "description": "Gets the scrollable parents that are registered with this drop container.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the scrollable parents that are registered with this drop container. */"
+          },
+          "entryType": "function",
+          "description": "Gets the scrollable parents that are registered with this drop container.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the scrollable parents that are registered with this drop container. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getItemIndex",
+          "signatures": [
+            {
+              "name": "getItemIndex",
+              "entryType": "function",
+              "description": "Figures out the index of an item in the container.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Item whose index should be determined."
+                }
+              ],
+              "params": [
+                {
+                  "name": "item",
+                  "description": "Item whose index should be determined.",
+                  "type": "DragRef<any>",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Figures out the index of an item in the container.\n   * @param item Item whose index should be determined.\n   */",
+              "returnType": "number"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "item",
+                "description": "Item whose index should be determined.",
+                "type": "DragRef<any>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "number",
+            "generics": [],
+            "name": "getItemIndex",
+            "description": "Figures out the index of an item in the container.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Item whose index should be determined."
+              }
+            ],
+            "rawComment": "/**\n   * Figures out the index of an item in the container.\n   * @param item Item whose index should be determined.\n   */"
+          },
+          "entryType": "function",
+          "description": "Figures out the index of an item in the container.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Item whose index should be determined."
+            }
+          ],
+          "rawComment": "/**\n   * Figures out the index of an item in the container.\n   * @param item Item whose index should be determined.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "isReceiving",
+          "signatures": [
+            {
+              "name": "isReceiving",
+              "entryType": "function",
+              "description": "Whether the list is able to receive the item that\nis currently being dragged inside a connected drop list.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/**\n   * Whether the list is able to receive the item that\n   * is currently being dragged inside a connected drop list.\n   */",
+              "returnType": "boolean"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "boolean",
+            "generics": [],
+            "name": "isReceiving",
+            "description": "Whether the list is able to receive the item that\nis currently being dragged inside a connected drop list.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Whether the list is able to receive the item that\n   * is currently being dragged inside a connected drop list.\n   */"
+          },
+          "entryType": "function",
+          "description": "Whether the list is able to receive the item that\nis currently being dragged inside a connected drop list.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Whether the list is able to receive the item that\n   * is currently being dragged inside a connected drop list.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        }
+      ],
+      "description": "Reference to a drop list. Used to manipulate or dispose of the container.",
+      "jsdocTags": [],
+      "rawComment": "/**\n * Reference to a drop list. Used to manipulate or dispose of the container.\n */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drop-list-ref.ts",
+        "startLine": 55,
+        "endLine": 772
+      }
+    },
+    {
+      "name": "CDK_DROP_LIST",
+      "type": "any",
+      "entryType": "constant",
+      "rawComment": "/**\n * Injection token that can be used to reference instances of `CdkDropList`. It serves as\n * alternative token to the actual `CdkDropList` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */",
+      "description": "Injection token that can be used to reference instances of `CdkDropList`. It serves as\nalternative token to the actual `CdkDropList` class which could cause unnecessary\nretention of the class and its directive metadata.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drag.ts",
+        "startLine": 58,
+        "endLine": 58
+      }
+    },
+    {
+      "name": "CdkDrag",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [
+            {
+              "name": "constructor",
+              "params": [
+                {
+                  "name": "args",
+                  "description": "",
+                  "type": "unknown[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "returnType": "CdkDrag",
+              "description": "",
+              "entryType": "function",
+              "jsdocTags": [],
+              "rawComment": "",
+              "generics": [],
+              "isNewType": false
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "CdkDrag<T>",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "element",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "dropContainer",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "data",
+          "type": "T",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Arbitrary data to attach to this drag instance.",
+          "jsdocTags": []
+        },
+        {
+          "name": "lockAxis",
+          "type": "DragAxis",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Locks the position of the dragged element along the specified axis.",
+          "jsdocTags": []
+        },
+        {
+          "name": "rootElementSelector",
+          "type": "string",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Selector that will be used to determine the root draggable element, starting from\nthe `cdkDrag` element and going up the DOM. Passing an alternate root element is useful\nwhen trying to enable dragging on an element that you might not have access to.",
+          "jsdocTags": []
+        },
+        {
+          "name": "boundaryElement",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Node or selector that will be used to determine the element to which the draggable's\nposition will be constrained. If a string is passed in, it'll be used as a selector that\nwill be matched starting from the element's parent and going up the DOM until a match\nhas been found.",
+          "jsdocTags": []
+        },
+        {
+          "name": "dragStartDelay",
+          "type": "DragStartDelay",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Amount of milliseconds to wait after the user has put their\npointer down before starting to drag the element.",
+          "jsdocTags": []
+        },
+        {
+          "name": "freeDragPosition",
+          "type": "Point",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Sets the position of a `CdkDrag` that is outside of a drop container.\nCan be used to restore the element's position for a returning user.",
+          "jsdocTags": []
+        },
+        {
+          "name": "disabled",
+          "type": "boolean",
+          "memberType": "getter",
+          "memberTags": [],
+          "description": "Whether starting to drag this element is disabled.",
+          "jsdocTags": []
+        },
+        {
+          "name": "disabled",
+          "type": "boolean",
+          "memberType": "setter",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "constrainPosition",
+          "type": "((userPointerPosition: Point, dragRef: DragRef<any>, dimensions: DOMRect, pickupPositionInElement: Point) => Point) | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "Function that can be used to customize the logic of how the position of the drag item\nis limited while it's being dragged. Gets called with a point containing the current position\nof the user's pointer on the page, a reference to the item being dragged and its dimensions.\nShould return a point describing where the item should be rendered.",
+          "jsdocTags": []
+        },
+        {
+          "name": "previewClass",
+          "type": "string | string[]",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Class to be added to the preview element.",
+          "jsdocTags": []
+        },
+        {
+          "name": "previewContainer",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Configures the place into which the preview of the item will be inserted. Can be configured\nglobally through `CDK_DROP_LIST`. Possible values:\n- `global` - Preview will be inserted at the bottom of the `<body>`. The advantage is that\nyou don't have to worry about `overflow: hidden` or `z-index`, but the item won't retain\nits inherited styles.\n- `parent` - Preview will be inserted into the parent of the drag item. The advantage is that\ninherited styles will be preserved, but it may be clipped by `overflow: hidden` or not be\nvisible due to `z-index`. Furthermore, the preview is going to have an effect over selectors\nlike `:nth-child` and some flexbox configurations.\n- `ElementRef<HTMLElement> | HTMLElement` - Preview will be inserted into a specific element.\nSame advantages and disadvantages as `parent`.",
+          "jsdocTags": []
+        },
+        {
+          "name": "scale",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "If the parent of the dragged element has a `scale` transform, it can throw off the\npositioning when the user starts dragging. Use this input to notify the CDK of the scale.",
+          "jsdocTags": []
+        },
+        {
+          "name": "started",
+          "type": "EventEmitter<CdkDragStart<any>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user starts dragging the item.",
+          "jsdocTags": []
+        },
+        {
+          "name": "released",
+          "type": "EventEmitter<CdkDragRelease<any>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user has released a drag item, before any animations have started.",
+          "jsdocTags": []
+        },
+        {
+          "name": "ended",
+          "type": "EventEmitter<CdkDragEnd<any>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user stops dragging an item in the container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "entered",
+          "type": "EventEmitter<CdkDragEnter<any, any>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user has moved the item into a new container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "exited",
+          "type": "EventEmitter<CdkDragExit<any, any>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user removes the item its container by dragging it into another container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "dropped",
+          "type": "EventEmitter<CdkDragDrop<any, any, any>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user drops the item inside a container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "moved",
+          "type": "Observable<CdkDragMove<T>>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits as the user is dragging the item. Use with caution,\nbecause this event will fire for every pixel that the user has dragged.",
+          "jsdocTags": []
+        },
+        {
+          "name": "getPlaceholderElement",
+          "signatures": [
+            {
+              "name": "getPlaceholderElement",
+              "entryType": "function",
+              "description": "Returns the element that is being used as a placeholder\nwhile the current element is being dragged.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/**\n   * Returns the element that is being used as a placeholder\n   * while the current element is being dragged.\n   */",
+              "returnType": "HTMLElement"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "HTMLElement",
+            "generics": [],
+            "name": "getPlaceholderElement",
+            "description": "Returns the element that is being used as a placeholder\nwhile the current element is being dragged.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Returns the element that is being used as a placeholder\n   * while the current element is being dragged.\n   */"
+          },
+          "entryType": "function",
+          "description": "Returns the element that is being used as a placeholder\nwhile the current element is being dragged.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Returns the element that is being used as a placeholder\n   * while the current element is being dragged.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getRootElement",
+          "signatures": [
+            {
+              "name": "getRootElement",
+              "entryType": "function",
+              "description": "Returns the root draggable element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Returns the root draggable element. */",
+              "returnType": "HTMLElement"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "HTMLElement",
+            "generics": [],
+            "name": "getRootElement",
+            "description": "Returns the root draggable element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Returns the root draggable element. */"
+          },
+          "entryType": "function",
+          "description": "Returns the root draggable element.",
+          "jsdocTags": [],
+          "rawComment": "/** Returns the root draggable element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "reset",
+          "signatures": [
+            {
+              "name": "reset",
+              "entryType": "function",
+              "description": "Resets a standalone drag item to its initial position.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Resets a standalone drag item to its initial position. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "reset",
+            "description": "Resets a standalone drag item to its initial position.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Resets a standalone drag item to its initial position. */"
+          },
+          "entryType": "function",
+          "description": "Resets a standalone drag item to its initial position.",
+          "jsdocTags": [],
+          "rawComment": "/** Resets a standalone drag item to its initial position. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getFreeDragPosition",
+          "signatures": [
+            {
+              "name": "getFreeDragPosition",
+              "entryType": "function",
+              "description": "Gets the pixel coordinates of the draggable outside of a drop container.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/**\n   * Gets the pixel coordinates of the draggable outside of a drop container.\n   */",
+              "returnType": "Readonly<Point>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Readonly<Point>",
+            "generics": [],
+            "name": "getFreeDragPosition",
+            "description": "Gets the pixel coordinates of the draggable outside of a drop container.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Gets the pixel coordinates of the draggable outside of a drop container.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets the pixel coordinates of the draggable outside of a drop container.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Gets the pixel coordinates of the draggable outside of a drop container.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "setFreeDragPosition",
+          "signatures": [
+            {
+              "name": "setFreeDragPosition",
+              "entryType": "function",
+              "description": "Sets the current position in pixels the draggable outside of a drop container.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "New position to be set."
+                }
+              ],
+              "params": [
+                {
+                  "name": "value",
+                  "description": "New position to be set.",
+                  "type": "Point",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets the current position in pixels the draggable outside of a drop container.\n   * @param value New position to be set.\n   */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "value",
+                "description": "New position to be set.",
+                "type": "Point",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "setFreeDragPosition",
+            "description": "Sets the current position in pixels the draggable outside of a drop container.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "New position to be set."
+              }
+            ],
+            "rawComment": "/**\n   * Sets the current position in pixels the draggable outside of a drop container.\n   * @param value New position to be set.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets the current position in pixels the draggable outside of a drop container.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "New position to be set."
+            }
+          ],
+          "rawComment": "/**\n   * Sets the current position in pixels the draggable outside of a drop container.\n   * @param value New position to be set.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "ngAfterViewInit",
+          "signatures": [
+            {
+              "name": "ngAfterViewInit",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "ngAfterViewInit",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "ngOnChanges",
+          "signatures": [
+            {
+              "name": "ngOnChanges",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "changes",
+                  "description": "",
+                  "type": "SimpleChanges",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "changes",
+                "description": "",
+                "type": "SimpleChanges",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "ngOnChanges",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "ngOnDestroy",
+          "signatures": [
+            {
+              "name": "ngOnDestroy",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "ngOnDestroy",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        }
+      ],
+      "description": "Element that can be moved inside a CdkDropList container.",
+      "jsdocTags": [],
+      "rawComment": "/** Element that can be moved inside a CdkDropList container. */",
+      "implements": [
+        "AfterViewInit",
+        "OnChanges",
+        "OnDestroy"
+      ],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/directives/drag.ts",
+        "startLine": 61,
+        "endLine": 623
+      }
+    },
+    {
+      "name": "CdkDragDrop",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "previousIndex",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Index of the item when it was picked up.",
+          "jsdocTags": []
+        },
+        {
+          "name": "currentIndex",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Current index of the item.",
+          "jsdocTags": []
+        },
+        {
+          "name": "item",
+          "type": "CdkDrag<I>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Item that is being dropped.",
+          "jsdocTags": []
+        },
+        {
+          "name": "container",
+          "type": "CdkDropList<T>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Container in which the item was dropped.",
+          "jsdocTags": []
+        },
+        {
+          "name": "previousContainer",
+          "type": "CdkDropList<O>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Container from which the item was picked up. Can be the same as the `container`.",
+          "jsdocTags": []
+        },
+        {
+          "name": "isPointerOverContainer",
+          "type": "boolean",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Whether the user's pointer was over the container when the item was dropped.",
+          "jsdocTags": []
+        },
+        {
+          "name": "distance",
+          "type": "{ x: number; y: number; }",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Distance in pixels that the user has dragged since the drag sequence started.",
+          "jsdocTags": []
+        },
+        {
+          "name": "dropPoint",
+          "type": "{ x: number; y: number; }",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Position where the pointer was when the item was dropped",
+          "jsdocTags": []
+        },
+        {
+          "name": "event",
+          "type": "MouseEvent | TouchEvent",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Native event that caused the drop event.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T"
+        },
+        {
+          "name": "O",
+          "default": "T"
+        },
+        {
+          "name": "I",
+          "default": "any"
+        }
+      ],
+      "description": "Event emitted when the user drops a draggable item inside a drop container.",
+      "jsdocTags": [],
+      "rawComment": "/** Event emitted when the user drops a draggable item inside a drop container. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-events.ts",
+        "startLine": 62,
+        "endLine": 81
+      }
+    },
+    {
+      "name": "Point",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "x",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "y",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [],
+      "description": "Point on the page or within an element.",
+      "jsdocTags": [],
+      "rawComment": "/** Point on the page or within an element. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-ref.ts",
+        "startLine": 91,
+        "endLine": 94
+      }
+    },
+    {
+      "name": "CdkDragMove",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "source",
+          "type": "CdkDrag<T>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Item that is being dragged.",
+          "jsdocTags": []
+        },
+        {
+          "name": "pointerPosition",
+          "type": "{ x: number; y: number; }",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Position of the user's pointer on the page.",
+          "jsdocTags": []
+        },
+        {
+          "name": "event",
+          "type": "MouseEvent | TouchEvent",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Native event that is causing the dragging.",
+          "jsdocTags": []
+        },
+        {
+          "name": "distance",
+          "type": "{ x: number; y: number; }",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Distance in pixels that the user has dragged since the drag sequence started.",
+          "jsdocTags": []
+        },
+        {
+          "name": "delta",
+          "type": "{ x: 0 | 1 | -1; y: 0 | 1 | -1; }",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Indicates the direction in which the user is dragging the element along each axis.\n`1` means that the position is increasing (e.g. the user is moving to the right or downwards),\nwhereas `-1` means that it's decreasing (they're moving to the left or upwards). `0` means\nthat the position hasn't changed.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        }
+      ],
+      "description": "Event emitted as the user is dragging a draggable item.",
+      "jsdocTags": [],
+      "rawComment": "/** Event emitted as the user is dragging a draggable item. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-events.ts",
+        "startLine": 84,
+        "endLine": 100
+      }
+    },
+    {
+      "name": "PreviewContainer",
+      "type": "'global' | 'parent' | ElementRef<HTMLElement> | HTMLElement",
+      "entryType": "type_alias",
+      "generics": [],
+      "rawComment": "/**\n * Possible places into which the preview of a drag item can be inserted.\n * - `global` - Preview will be inserted at the bottom of the `<body>`. The advantage is that\n * you don't have to worry about `overflow: hidden` or `z-index`, but the item won't retain\n * its inherited styles.\n * - `parent` - Preview will be inserted into the parent of the drag item. The advantage is that\n * inherited styles will be preserved, but it may be clipped by `overflow: hidden` or not be\n * visible due to `z-index`. Furthermore, the preview is going to have an effect over selectors\n * like `:nth-child` and some flexbox configurations.\n * - `ElementRef<HTMLElement> | HTMLElement` - Preview will be inserted into a specific element.\n * Same advantages and disadvantages as `parent`.\n */",
+      "description": "Possible places into which the preview of a drag item can be inserted.\n- `global` - Preview will be inserted at the bottom of the `<body>`. The advantage is that\nyou don't have to worry about `overflow: hidden` or `z-index`, but the item won't retain\nits inherited styles.\n- `parent` - Preview will be inserted into the parent of the drag item. The advantage is that\ninherited styles will be preserved, but it may be clipped by `overflow: hidden` or not be\nvisible due to `z-index`. Furthermore, the preview is going to have an effect over selectors\nlike `:nth-child` and some flexbox configurations.\n- `ElementRef<HTMLElement> | HTMLElement` - Preview will be inserted into a specific element.\nSame advantages and disadvantages as `parent`.",
+      "jsdocTags": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-ref.ts",
+        "startLine": 114,
+        "endLine": 114
+      }
+    },
+    {
+      "name": "CdkDragSortEvent",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "previousIndex",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Index from which the item was sorted previously.",
+          "jsdocTags": []
+        },
+        {
+          "name": "currentIndex",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Index that the item is currently in.",
+          "jsdocTags": []
+        },
+        {
+          "name": "container",
+          "type": "CdkDropList<T>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Container that the item belongs to.",
+          "jsdocTags": []
+        },
+        {
+          "name": "item",
+          "type": "CdkDrag<I>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Item that is being sorted.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        },
+        {
+          "name": "I",
+          "default": "T"
+        }
+      ],
+      "description": "Event emitted when the user swaps the position of two drag items.",
+      "jsdocTags": [],
+      "rawComment": "/** Event emitted when the user swaps the position of two drag items. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-events.ts",
+        "startLine": 103,
+        "endLine": 112
+      }
+    },
+    {
+      "name": "DragRef",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "any",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_config",
+                "description": "",
+                "type": "DragRefConfig",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_document",
+                "description": "",
+                "type": "Document",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_ngZone",
+                "description": "",
+                "type": "NgZone",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_viewportRuler",
+                "description": "",
+                "type": "ViewportRuler",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_dragDropRegistry",
+                "description": "",
+                "type": "DragDropRegistry<unknown, unknown>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_renderer",
+                "description": "",
+                "type": "Renderer2",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "DragRef<T>",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "lockAxis",
+          "type": "\"x\" | \"y\"",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Axis along which dragging is locked.",
+          "jsdocTags": []
+        },
+        {
+          "name": "dragStartDelay",
+          "type": "number | { touch: number; mouse: number; }",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Amount of milliseconds to wait after the user has put their\npointer down before starting to drag the element.",
+          "jsdocTags": []
+        },
+        {
+          "name": "previewClass",
+          "type": "string | string[] | undefined",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Class to be added to the preview element.",
+          "jsdocTags": []
+        },
+        {
+          "name": "scale",
+          "type": "number",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "If the parent of the dragged element has a `scale` transform, it can throw off the\npositioning when the user starts dragging. Use this input to notify the CDK of the scale.",
+          "jsdocTags": []
+        },
+        {
+          "name": "disabled",
+          "type": "boolean",
+          "memberType": "getter",
+          "memberTags": [],
+          "description": "Whether starting to drag this element is disabled.",
+          "jsdocTags": []
+        },
+        {
+          "name": "disabled",
+          "type": "boolean",
+          "memberType": "setter",
+          "memberTags": [],
+          "description": "",
+          "jsdocTags": []
+        },
+        {
+          "name": "beforeStarted",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits as the drag sequence is being prepared.",
+          "jsdocTags": []
+        },
+        {
+          "name": "started",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user starts dragging the item.",
+          "jsdocTags": []
+        },
+        {
+          "name": "released",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user has released a drag item, before any animations have started.",
+          "jsdocTags": []
+        },
+        {
+          "name": "ended",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user stops dragging an item in the container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "entered",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user has moved the item into a new container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "exited",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user removes the item its container by dragging it into another container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "dropped",
+          "type": "any",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits when the user drops the item inside a container.",
+          "jsdocTags": []
+        },
+        {
+          "name": "moved",
+          "type": "Observable<{ source: DragRef<any>; pointerPosition: { x: number; y: number; }; event: MouseEvent | TouchEvent; distance: Point; delta: { x: 0 | 1 | -1; y: 0 | 1 | -1; }; }>",
+          "memberType": "property",
+          "memberTags": [
+            "readonly"
+          ],
+          "description": "Emits as the user is dragging the item. Use with caution,\nbecause this event will fire for every pixel that the user has dragged.",
+          "jsdocTags": []
+        },
+        {
+          "name": "data",
+          "type": "T",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "Arbitrary data that can be attached to the drag item.",
+          "jsdocTags": []
+        },
+        {
+          "name": "constrainPosition",
+          "type": "((userPointerPosition: Point, dragRef: DragRef<any>, dimensions: DOMRect, pickupPositionInElement: Point) => Point) | undefined",
+          "memberType": "property",
+          "memberTags": [
+            "optional"
+          ],
+          "description": "Function that can be used to customize the logic of how the position of the drag item\nis limited while it's being dragged. Gets called with a point containing the current position\nof the user's pointer on the page, a reference to the item being dragged and its dimensions.\nShould return a point describing where the item should be rendered.",
+          "jsdocTags": []
+        },
+        {
+          "name": "getPlaceholderElement",
+          "signatures": [
+            {
+              "name": "getPlaceholderElement",
+              "entryType": "function",
+              "description": "Returns the element that is being used as a placeholder\nwhile the current element is being dragged.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/**\n   * Returns the element that is being used as a placeholder\n   * while the current element is being dragged.\n   */",
+              "returnType": "HTMLElement"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "HTMLElement",
+            "generics": [],
+            "name": "getPlaceholderElement",
+            "description": "Returns the element that is being used as a placeholder\nwhile the current element is being dragged.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Returns the element that is being used as a placeholder\n   * while the current element is being dragged.\n   */"
+          },
+          "entryType": "function",
+          "description": "Returns the element that is being used as a placeholder\nwhile the current element is being dragged.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Returns the element that is being used as a placeholder\n   * while the current element is being dragged.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getRootElement",
+          "signatures": [
+            {
+              "name": "getRootElement",
+              "entryType": "function",
+              "description": "Returns the root draggable element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Returns the root draggable element. */",
+              "returnType": "HTMLElement"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "HTMLElement",
+            "generics": [],
+            "name": "getRootElement",
+            "description": "Returns the root draggable element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Returns the root draggable element. */"
+          },
+          "entryType": "function",
+          "description": "Returns the root draggable element.",
+          "jsdocTags": [],
+          "rawComment": "/** Returns the root draggable element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getVisibleElement",
+          "signatures": [
+            {
+              "name": "getVisibleElement",
+              "entryType": "function",
+              "description": "Gets the currently-visible element that represents the drag item.\nWhile dragging this is the placeholder, otherwise it's the root element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/**\n   * Gets the currently-visible element that represents the drag item.\n   * While dragging this is the placeholder, otherwise it's the root element.\n   */",
+              "returnType": "HTMLElement"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "HTMLElement",
+            "generics": [],
+            "name": "getVisibleElement",
+            "description": "Gets the currently-visible element that represents the drag item.\nWhile dragging this is the placeholder, otherwise it's the root element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Gets the currently-visible element that represents the drag item.\n   * While dragging this is the placeholder, otherwise it's the root element.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets the currently-visible element that represents the drag item.\nWhile dragging this is the placeholder, otherwise it's the root element.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Gets the currently-visible element that represents the drag item.\n   * While dragging this is the placeholder, otherwise it's the root element.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withHandles",
+          "signatures": [
+            {
+              "name": "withHandles",
+              "entryType": "function",
+              "description": "Registers the handles that can be used to drag the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "handles",
+                  "description": "",
+                  "type": "any[]",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Registers the handles that can be used to drag the element. */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "handles",
+                "description": "",
+                "type": "any[]",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withHandles",
+            "description": "Registers the handles that can be used to drag the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Registers the handles that can be used to drag the element. */"
+          },
+          "entryType": "function",
+          "description": "Registers the handles that can be used to drag the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Registers the handles that can be used to drag the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withPreviewTemplate",
+          "signatures": [
+            {
+              "name": "withPreviewTemplate",
+              "entryType": "function",
+              "description": "Registers the template that should be used for the drag preview.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Template that from which to stamp out the preview."
+                }
+              ],
+              "params": [
+                {
+                  "name": "template",
+                  "description": "Template that from which to stamp out the preview.",
+                  "type": "DragPreviewTemplate<any> | null",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Registers the template that should be used for the drag preview.\n   * @param template Template that from which to stamp out the preview.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "template",
+                "description": "Template that from which to stamp out the preview.",
+                "type": "DragPreviewTemplate<any> | null",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withPreviewTemplate",
+            "description": "Registers the template that should be used for the drag preview.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Template that from which to stamp out the preview."
+              }
+            ],
+            "rawComment": "/**\n   * Registers the template that should be used for the drag preview.\n   * @param template Template that from which to stamp out the preview.\n   */"
+          },
+          "entryType": "function",
+          "description": "Registers the template that should be used for the drag preview.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Template that from which to stamp out the preview."
+            }
+          ],
+          "rawComment": "/**\n   * Registers the template that should be used for the drag preview.\n   * @param template Template that from which to stamp out the preview.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withPlaceholderTemplate",
+          "signatures": [
+            {
+              "name": "withPlaceholderTemplate",
+              "entryType": "function",
+              "description": "Registers the template that should be used for the drag placeholder.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Template that from which to stamp out the placeholder."
+                }
+              ],
+              "params": [
+                {
+                  "name": "template",
+                  "description": "Template that from which to stamp out the placeholder.",
+                  "type": "DragHelperTemplate<any> | null",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Registers the template that should be used for the drag placeholder.\n   * @param template Template that from which to stamp out the placeholder.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "template",
+                "description": "Template that from which to stamp out the placeholder.",
+                "type": "DragHelperTemplate<any> | null",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withPlaceholderTemplate",
+            "description": "Registers the template that should be used for the drag placeholder.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Template that from which to stamp out the placeholder."
+              }
+            ],
+            "rawComment": "/**\n   * Registers the template that should be used for the drag placeholder.\n   * @param template Template that from which to stamp out the placeholder.\n   */"
+          },
+          "entryType": "function",
+          "description": "Registers the template that should be used for the drag placeholder.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Template that from which to stamp out the placeholder."
+            }
+          ],
+          "rawComment": "/**\n   * Registers the template that should be used for the drag placeholder.\n   * @param template Template that from which to stamp out the placeholder.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withRootElement",
+          "signatures": [
+            {
+              "name": "withRootElement",
+              "entryType": "function",
+              "description": "Sets an alternate drag root element. The root element is the element that will be moved as\nthe user is dragging. Passing an alternate root element is useful when trying to enable\ndragging on an element that you might not have access to.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "rootElement",
+                  "description": "",
+                  "type": "any",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets an alternate drag root element. The root element is the element that will be moved as\n   * the user is dragging. Passing an alternate root element is useful when trying to enable\n   * dragging on an element that you might not have access to.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "rootElement",
+                "description": "",
+                "type": "any",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withRootElement",
+            "description": "Sets an alternate drag root element. The root element is the element that will be moved as\nthe user is dragging. Passing an alternate root element is useful when trying to enable\ndragging on an element that you might not have access to.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Sets an alternate drag root element. The root element is the element that will be moved as\n   * the user is dragging. Passing an alternate root element is useful when trying to enable\n   * dragging on an element that you might not have access to.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets an alternate drag root element. The root element is the element that will be moved as\nthe user is dragging. Passing an alternate root element is useful when trying to enable\ndragging on an element that you might not have access to.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Sets an alternate drag root element. The root element is the element that will be moved as\n   * the user is dragging. Passing an alternate root element is useful when trying to enable\n   * dragging on an element that you might not have access to.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withBoundaryElement",
+          "signatures": [
+            {
+              "name": "withBoundaryElement",
+              "entryType": "function",
+              "description": "Element to which the draggable's position will be constrained.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "boundaryElement",
+                  "description": "",
+                  "type": "any",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Element to which the draggable's position will be constrained.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "boundaryElement",
+                "description": "",
+                "type": "any",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withBoundaryElement",
+            "description": "Element to which the draggable's position will be constrained.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Element to which the draggable's position will be constrained.\n   */"
+          },
+          "entryType": "function",
+          "description": "Element to which the draggable's position will be constrained.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Element to which the draggable's position will be constrained.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withParent",
+          "signatures": [
+            {
+              "name": "withParent",
+              "entryType": "function",
+              "description": "Sets the parent ref that the ref is nested in.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "parent",
+                  "description": "",
+                  "type": "DragRef<unknown> | null",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Sets the parent ref that the ref is nested in.  */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "parent",
+                "description": "",
+                "type": "DragRef<unknown> | null",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withParent",
+            "description": "Sets the parent ref that the ref is nested in.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Sets the parent ref that the ref is nested in.  */"
+          },
+          "entryType": "function",
+          "description": "Sets the parent ref that the ref is nested in.",
+          "jsdocTags": [],
+          "rawComment": "/** Sets the parent ref that the ref is nested in.  */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "dispose",
+          "signatures": [
+            {
+              "name": "dispose",
+              "entryType": "function",
+              "description": "Removes the dragging functionality from the DOM element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Removes the dragging functionality from the DOM element. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "dispose",
+            "description": "Removes the dragging functionality from the DOM element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Removes the dragging functionality from the DOM element. */"
+          },
+          "entryType": "function",
+          "description": "Removes the dragging functionality from the DOM element.",
+          "jsdocTags": [],
+          "rawComment": "/** Removes the dragging functionality from the DOM element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "isDragging",
+          "signatures": [
+            {
+              "name": "isDragging",
+              "entryType": "function",
+              "description": "Checks whether the element is currently being dragged.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Checks whether the element is currently being dragged. */",
+              "returnType": "boolean"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "boolean",
+            "generics": [],
+            "name": "isDragging",
+            "description": "Checks whether the element is currently being dragged.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Checks whether the element is currently being dragged. */"
+          },
+          "entryType": "function",
+          "description": "Checks whether the element is currently being dragged.",
+          "jsdocTags": [],
+          "rawComment": "/** Checks whether the element is currently being dragged. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "reset",
+          "signatures": [
+            {
+              "name": "reset",
+              "entryType": "function",
+              "description": "Resets a standalone drag item to its initial position.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Resets a standalone drag item to its initial position. */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "reset",
+            "description": "Resets a standalone drag item to its initial position.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Resets a standalone drag item to its initial position. */"
+          },
+          "entryType": "function",
+          "description": "Resets a standalone drag item to its initial position.",
+          "jsdocTags": [],
+          "rawComment": "/** Resets a standalone drag item to its initial position. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "disableHandle",
+          "signatures": [
+            {
+              "name": "disableHandle",
+              "entryType": "function",
+              "description": "Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Handle element that should be disabled."
+                }
+              ],
+              "params": [
+                {
+                  "name": "handle",
+                  "description": "Handle element that should be disabled.",
+                  "type": "HTMLElement",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.\n   * @param handle Handle element that should be disabled.\n   */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "handle",
+                "description": "Handle element that should be disabled.",
+                "type": "HTMLElement",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "disableHandle",
+            "description": "Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Handle element that should be disabled."
+              }
+            ],
+            "rawComment": "/**\n   * Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.\n   * @param handle Handle element that should be disabled.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Handle element that should be disabled."
+            }
+          ],
+          "rawComment": "/**\n   * Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.\n   * @param handle Handle element that should be disabled.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "enableHandle",
+          "signatures": [
+            {
+              "name": "enableHandle",
+              "entryType": "function",
+              "description": "Enables a handle, if it has been disabled.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Handle element to be enabled."
+                }
+              ],
+              "params": [
+                {
+                  "name": "handle",
+                  "description": "Handle element to be enabled.",
+                  "type": "HTMLElement",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Enables a handle, if it has been disabled.\n   * @param handle Handle element to be enabled.\n   */",
+              "returnType": "void"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "handle",
+                "description": "Handle element to be enabled.",
+                "type": "HTMLElement",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "void",
+            "generics": [],
+            "name": "enableHandle",
+            "description": "Enables a handle, if it has been disabled.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Handle element to be enabled."
+              }
+            ],
+            "rawComment": "/**\n   * Enables a handle, if it has been disabled.\n   * @param handle Handle element to be enabled.\n   */"
+          },
+          "entryType": "function",
+          "description": "Enables a handle, if it has been disabled.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Handle element to be enabled."
+            }
+          ],
+          "rawComment": "/**\n   * Enables a handle, if it has been disabled.\n   * @param handle Handle element to be enabled.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withDirection",
+          "signatures": [
+            {
+              "name": "withDirection",
+              "entryType": "function",
+              "description": "Sets the layout direction of the draggable item.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "direction",
+                  "description": "",
+                  "type": "Direction",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Sets the layout direction of the draggable item. */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "direction",
+                "description": "",
+                "type": "Direction",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withDirection",
+            "description": "Sets the layout direction of the draggable item.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Sets the layout direction of the draggable item. */"
+          },
+          "entryType": "function",
+          "description": "Sets the layout direction of the draggable item.",
+          "jsdocTags": [],
+          "rawComment": "/** Sets the layout direction of the draggable item. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getFreeDragPosition",
+          "signatures": [
+            {
+              "name": "getFreeDragPosition",
+              "entryType": "function",
+              "description": "Gets the current position in pixels the draggable outside of a drop container.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/**\n   * Gets the current position in pixels the draggable outside of a drop container.\n   */",
+              "returnType": "Readonly<Point>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Readonly<Point>",
+            "generics": [],
+            "name": "getFreeDragPosition",
+            "description": "Gets the current position in pixels the draggable outside of a drop container.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Gets the current position in pixels the draggable outside of a drop container.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets the current position in pixels the draggable outside of a drop container.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Gets the current position in pixels the draggable outside of a drop container.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "setFreeDragPosition",
+          "signatures": [
+            {
+              "name": "setFreeDragPosition",
+              "entryType": "function",
+              "description": "Sets the current position in pixels the draggable outside of a drop container.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "New position to be set."
+                }
+              ],
+              "params": [
+                {
+                  "name": "value",
+                  "description": "New position to be set.",
+                  "type": "Point",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets the current position in pixels the draggable outside of a drop container.\n   * @param value New position to be set.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "value",
+                "description": "New position to be set.",
+                "type": "Point",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "setFreeDragPosition",
+            "description": "Sets the current position in pixels the draggable outside of a drop container.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "New position to be set."
+              }
+            ],
+            "rawComment": "/**\n   * Sets the current position in pixels the draggable outside of a drop container.\n   * @param value New position to be set.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets the current position in pixels the draggable outside of a drop container.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "New position to be set."
+            }
+          ],
+          "rawComment": "/**\n   * Sets the current position in pixels the draggable outside of a drop container.\n   * @param value New position to be set.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "withPreviewContainer",
+          "signatures": [
+            {
+              "name": "withPreviewContainer",
+              "entryType": "function",
+              "description": "Sets the container into which to insert the preview element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Container into which to insert the preview."
+                }
+              ],
+              "params": [
+                {
+                  "name": "value",
+                  "description": "Container into which to insert the preview.",
+                  "type": "any",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets the container into which to insert the preview element.\n   * @param value Container into which to insert the preview.\n   */",
+              "returnType": "this"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "value",
+                "description": "Container into which to insert the preview.",
+                "type": "any",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "this",
+            "generics": [],
+            "name": "withPreviewContainer",
+            "description": "Sets the container into which to insert the preview element.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Container into which to insert the preview."
+              }
+            ],
+            "rawComment": "/**\n   * Sets the container into which to insert the preview element.\n   * @param value Container into which to insert the preview.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets the container into which to insert the preview element.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Container into which to insert the preview."
+            }
+          ],
+          "rawComment": "/**\n   * Sets the container into which to insert the preview element.\n   * @param value Container into which to insert the preview.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [
+        {
+          "name": "T",
+          "default": "any"
+        }
+      ],
+      "description": "Reference to a draggable item. Used to manipulate or dispose of the item.",
+      "jsdocTags": [],
+      "rawComment": "/**\n * Reference to a draggable item. Used to manipulate or dispose of the item.\n */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/drag-drop/drag-ref.ts",
+        "startLine": 119,
+        "endLine": 1559
+      }
+    }
+  ],
+  "symbols": [
+    [
+      "InjectionToken",
+      "@angular/core"
+    ],
+    [
+      "Directive",
+      "@angular/core"
+    ],
+    [
+      "OnDestroy",
+      "@angular/core"
+    ],
+    [
+      "Input",
+      "@angular/core"
+    ],
+    [
+      "booleanAttribute",
+      "@angular/core"
+    ],
+    [
+      "TemplateRef",
+      "@angular/core"
+    ],
+    [
+      "inject",
+      "@angular/core"
+    ],
+    [
+      "Injectable",
+      "@angular/core"
+    ],
+    [
+      "NgZone",
+      "@angular/core"
+    ],
+    [
+      "ElementRef",
+      "@angular/core"
+    ],
+    [
+      "RendererFactory2",
+      "@angular/core"
+    ],
+    [
+      "DOCUMENT",
+      "@angular/common"
+    ],
+    [
+      "NgModule",
+      "@angular/core"
+    ],
+    [
+      "AfterViewInit",
+      "@angular/core"
+    ],
+    [
+      "EventEmitter",
+      "@angular/core"
+    ],
+    [
+      "Output",
+      "@angular/core"
+    ],
+    [
+      "ChangeDetectorRef",
+      "@angular/core"
+    ],
+    [
+      "EmbeddedViewRef",
+      "@angular/core"
+    ],
+    [
+      "Renderer2",
+      "@angular/core"
+    ],
+    [
+      "ViewContainerRef",
+      "@angular/core"
+    ],
+    [
+      "signal",
+      "@angular/core"
+    ],
+    [
+      "ChangeDetectionStrategy",
+      "@angular/core"
+    ],
+    [
+      "Component",
+      "@angular/core"
+    ],
+    [
+      "ViewEncapsulation",
+      "@angular/core"
+    ],
+    [
+      "WritableSignal",
+      "@angular/core"
+    ],
+    [
+      "OnChanges",
+      "@angular/core"
+    ],
+    [
+      "SimpleChanges",
+      "@angular/core"
+    ],
+    [
+      "afterNextRender",
+      "@angular/core"
+    ],
+    [
+      "Injector",
+      "@angular/core"
+    ],
+    [
+      "numberAttribute",
+      "@angular/core"
+    ],
+    [
+      "moveItemInArray",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragStart",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragStartDelay",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragAxis",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DRAG_PARENT",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragConstrainPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DROP_LIST_GROUP",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragRelease",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DRAG_PLACEHOLDER",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DRAG_PREVIEW",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropListGroup",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDrop",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPlaceholder",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListOrientation",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPreview",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropModule",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DRAG_HANDLE",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "transferArrayItem",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnd",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragHandle",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DRAG_CONFIG",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRefConfig",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnter",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "copyArrayItem",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragExit",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DROP_LIST",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "Point",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragMove",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "PreviewContainer",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragSortEvent",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "moveItemInArray",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragStart",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragStart.source",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragStart.event",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragStartDelay",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragAxis",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DRAG_PARENT",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragConstrainPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DROP_LIST_GROUP",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragRelease",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragRelease.source",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragRelease.event",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DRAG_PLACEHOLDER",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DRAG_PREVIEW",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropListGroup",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropListGroup.disabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropListGroup.ngOnDestroy",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDrop",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDrop.constructor",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDrop.createDrag",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDrop.createDropList",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPlaceholder",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPlaceholder.constructor",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPlaceholder.templateRef",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPlaceholder.data",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPlaceholder.ngOnDestroy",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListOrientation",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPreview",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPreview.constructor",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPreview.templateRef",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPreview.data",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPreview.matchSize",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragPreview.ngOnDestroy",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropModule",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DRAG_HANDLE",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "transferArrayItem",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnd",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnd.source",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnd.distance",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnd.dropPoint",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnd.event",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragHandle",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragHandle.constructor",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragHandle.element",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragHandle.disabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragHandle.disabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragHandle.ngAfterViewInit",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragHandle.ngOnDestroy",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DRAG_CONFIG",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.lockAxis",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.dragStartDelay",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.constrainPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.previewClass",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.boundaryElement",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.rootElementSelector",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.draggingDisabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.sortingDisabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.listAutoScrollDisabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.listOrientation",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.zIndex",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.previewContainer",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.dragStartThreshold",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.pointerDirectionChangeThreshold",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropConfig.parentDragRef",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.constructor",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.element",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.connectedTo",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.data",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.orientation",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.id",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.lockAxis",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.disabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.disabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.sortingDisabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.enterPredicate",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.sortPredicate",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.autoScrollDisabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.autoScrollStep",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.elementContainerSelector",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.dropped",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.entered",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.exited",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.sorted",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.addItem",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.removeItem",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.getSortedItems",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDropList.ngOnDestroy",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRefConfig",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRefConfig.dragStartThreshold",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRefConfig.pointerDirectionChangeThreshold",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRefConfig.zIndex",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRefConfig.parentDragRef",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.constructor",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.pointerMove",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.pointerUp",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.scroll",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.registerDropContainer",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.registerDragItem",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.removeDropContainer",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.removeDragItem",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.startDragging",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.stopDragging",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.isDragging",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.scrolled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.registerDirectiveNode",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.removeDirectiveNode",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.getDragDirectiveForNode",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragDropRegistry.ngOnDestroy",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnter",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnter.container",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnter.item",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragEnter.currentIndex",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "copyArrayItem",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragExit",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragExit.container",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragExit.item",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.constructor",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.element",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.disabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.sortingDisabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.lockAxis",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.autoScrollDisabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.autoScrollStep",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.enterPredicate",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.sortPredicate",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.beforeStarted",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.entered",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.exited",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.dropped",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.sorted",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.receivingStarted",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.receivingStopped",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.data",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.dispose",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.isDragging",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.start",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.enter",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.exit",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.drop",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.withItems",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.withDirection",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.connectedTo",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.withOrientation",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.withScrollableParents",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.withElementContainer",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.getScrollableParents",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.getItemIndex",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DropListRef.isReceiving",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CDK_DROP_LIST",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.constructor",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.element",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.dropContainer",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.data",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.lockAxis",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.rootElementSelector",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.boundaryElement",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.dragStartDelay",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.freeDragPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.disabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.disabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.constrainPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.previewClass",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.previewContainer",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.scale",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.started",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.released",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.ended",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.entered",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.exited",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.dropped",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.moved",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.getPlaceholderElement",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.getRootElement",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.reset",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.getFreeDragPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.setFreeDragPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.ngAfterViewInit",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.ngOnChanges",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDrag.ngOnDestroy",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop.previousIndex",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop.currentIndex",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop.item",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop.container",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop.previousContainer",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop.isPointerOverContainer",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop.distance",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop.dropPoint",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragDrop.event",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "Point",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "Point.x",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "Point.y",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragMove",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragMove.source",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragMove.pointerPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragMove.event",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragMove.distance",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragMove.delta",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "PreviewContainer",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragSortEvent",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragSortEvent.previousIndex",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragSortEvent.currentIndex",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragSortEvent.container",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "CdkDragSortEvent.item",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.constructor",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.lockAxis",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.dragStartDelay",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.previewClass",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.scale",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.disabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.disabled",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.beforeStarted",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.started",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.released",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.ended",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.entered",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.exited",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.dropped",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.moved",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.data",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.constrainPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.getPlaceholderElement",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.getRootElement",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.getVisibleElement",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.withHandles",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.withPreviewTemplate",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.withPlaceholderTemplate",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.withRootElement",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.withBoundaryElement",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.withParent",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.dispose",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.isDragging",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.reset",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.disableHandle",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.enableHandle",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.withDirection",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.getFreeDragPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.setFreeDragPosition",
+      "@angular/cdk/drag-drop"
+    ],
+    [
+      "DragRef.withPreviewContainer",
+      "@angular/cdk/drag-drop"
+    ]
+  ]
+}

node_modules/@angular/cdk/_adev_assets/cdk_testing_protractor.json

@@ -0,0 +1,1747 @@
+{
+  "repo": "angular/components",
+  "moduleLabel": "@angular/cdk/testing/protractor",
+  "moduleName": "@angular/cdk/testing/protractor",
+  "normalizedModuleName": "angular_cdk_testing_protractor",
+  "entries": [
+    {
+      "name": "ProtractorHarnessEnvironmentOptions",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "queryFn",
+          "type": "(selector: string, root: ElementFinder) => ElementArrayFinder",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "The query function used to find DOM elements.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [],
+      "description": "Options to configure the environment.",
+      "jsdocTags": [
+        {
+          "name": "deprecated",
+          "comment": ""
+        },
+        {
+          "name": "breaking-change",
+          "comment": "13.0.0"
+        }
+      ],
+      "rawComment": "/**\n * Options to configure the environment.\n * @deprecated\n * @breaking-change 13.0.0\n */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/testing/protractor/protractor-harness-environment.ts",
+        "startLine": 18,
+        "endLine": 21
+      }
+    },
+    {
+      "name": "ProtractorHarnessEnvironment",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [],
+          "implementation": {
+            "params": [
+              {
+                "name": "rawRootElement",
+                "description": "",
+                "type": "ElementFinder",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "options",
+                "description": "",
+                "type": "ProtractorHarnessEnvironmentOptions | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "ProtractorHarnessEnvironment",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "forceStabilize",
+          "signatures": [
+            {
+              "name": "forceStabilize",
+              "entryType": "function",
+              "description": "Flushes change detection and async tasks captured in the Angular zone.\nIn most cases it should not be necessary to call this manually. However, there may be some edge\ncases where it is needed to fully flush animation events.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "forceStabilize",
+            "description": "Flushes change detection and async tasks captured in the Angular zone.\nIn most cases it should not be necessary to call this manually. However, there may be some edge\ncases where it is needed to fully flush animation events.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */"
+          },
+          "entryType": "function",
+          "description": "Flushes change detection and async tasks captured in the Angular zone.\nIn most cases it should not be necessary to call this manually. However, there may be some edge\ncases where it is needed to fully flush animation events.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "waitForTasksOutsideAngular",
+          "signatures": [
+            {
+              "name": "waitForTasksOutsideAngular",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "docs-private",
+                  "comment": ""
+                }
+              ],
+              "params": [],
+              "rawComment": "/** @docs-private */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "waitForTasksOutsideAngular",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "docs-private",
+                "comment": ""
+              }
+            ],
+            "rawComment": "/** @docs-private */"
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [
+            {
+              "name": "docs-private",
+              "comment": ""
+            }
+          ],
+          "rawComment": "/** @docs-private */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getDocumentRoot",
+          "signatures": [
+            {
+              "name": "getDocumentRoot",
+              "entryType": "function",
+              "description": "Gets the root element for the document.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Gets the root element for the document. */",
+              "returnType": "ElementFinder"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "ElementFinder",
+            "generics": [],
+            "name": "getDocumentRoot",
+            "description": "Gets the root element for the document.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the root element for the document. */"
+          },
+          "entryType": "function",
+          "description": "Gets the root element for the document.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the root element for the document. */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "createTestElement",
+          "signatures": [
+            {
+              "name": "createTestElement",
+              "entryType": "function",
+              "description": "Creates a `TestElement` from a raw element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "element",
+                  "description": "",
+                  "type": "ElementFinder",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Creates a `TestElement` from a raw element. */",
+              "returnType": "TestElement"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "ElementFinder",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "TestElement",
+            "generics": [],
+            "name": "createTestElement",
+            "description": "Creates a `TestElement` from a raw element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Creates a `TestElement` from a raw element. */"
+          },
+          "entryType": "function",
+          "description": "Creates a `TestElement` from a raw element.",
+          "jsdocTags": [],
+          "rawComment": "/** Creates a `TestElement` from a raw element. */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "createEnvironment",
+          "signatures": [
+            {
+              "name": "createEnvironment",
+              "entryType": "function",
+              "description": "Creates a `HarnessLoader` rooted at the given raw element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "element",
+                  "description": "",
+                  "type": "ElementFinder",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Creates a `HarnessLoader` rooted at the given raw element. */",
+              "returnType": "HarnessEnvironment<ElementFinder>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "ElementFinder",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "HarnessEnvironment<ElementFinder>",
+            "generics": [],
+            "name": "createEnvironment",
+            "description": "Creates a `HarnessLoader` rooted at the given raw element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Creates a `HarnessLoader` rooted at the given raw element. */"
+          },
+          "entryType": "function",
+          "description": "Creates a `HarnessLoader` rooted at the given raw element.",
+          "jsdocTags": [],
+          "rawComment": "/** Creates a `HarnessLoader` rooted at the given raw element. */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "getAllRawElements",
+          "signatures": [
+            {
+              "name": "getAllRawElements",
+              "entryType": "function",
+              "description": "Gets a list of all elements matching the given selector under this environment's root element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "selector",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */",
+              "returnType": "Promise<ElementFinder[]>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "selector",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<ElementFinder[]>",
+            "generics": [],
+            "name": "getAllRawElements",
+            "description": "Gets a list of all elements matching the given selector under this environment's root element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets a list of all elements matching the given selector under this environment's root element.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "loader",
+          "signatures": [
+            {
+              "name": "loader",
+              "entryType": "function",
+              "description": "Creates a `HarnessLoader` rooted at the document root.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "options",
+                  "description": "",
+                  "type": "ProtractorHarnessEnvironmentOptions | undefined",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Creates a `HarnessLoader` rooted at the document root. */",
+              "returnType": "HarnessLoader"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "options",
+                "description": "",
+                "type": "ProtractorHarnessEnvironmentOptions | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "HarnessLoader",
+            "generics": [],
+            "name": "loader",
+            "description": "Creates a `HarnessLoader` rooted at the document root.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Creates a `HarnessLoader` rooted at the document root. */"
+          },
+          "entryType": "function",
+          "description": "Creates a `HarnessLoader` rooted at the document root.",
+          "jsdocTags": [],
+          "rawComment": "/** Creates a `HarnessLoader` rooted at the document root. */",
+          "memberType": "method",
+          "memberTags": [
+            "static"
+          ]
+        },
+        {
+          "name": "getNativeElement",
+          "signatures": [
+            {
+              "name": "getNativeElement",
+              "entryType": "function",
+              "description": "Gets the ElementFinder corresponding to the given TestElement.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "el",
+                  "description": "",
+                  "type": "TestElement",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Gets the ElementFinder corresponding to the given TestElement. */",
+              "returnType": "ElementFinder"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "el",
+                "description": "",
+                "type": "TestElement",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "ElementFinder",
+            "generics": [],
+            "name": "getNativeElement",
+            "description": "Gets the ElementFinder corresponding to the given TestElement.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the ElementFinder corresponding to the given TestElement. */"
+          },
+          "entryType": "function",
+          "description": "Gets the ElementFinder corresponding to the given TestElement.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the ElementFinder corresponding to the given TestElement. */",
+          "memberType": "method",
+          "memberTags": [
+            "static"
+          ]
+        }
+      ],
+      "generics": [],
+      "description": "A `HarnessEnvironment` implementation for Protractor.",
+      "jsdocTags": [
+        {
+          "name": "deprecated",
+          "comment": "As of v13.0.0, this environment no longer works, as it is not\ncompatible with the new [Angular Package Format](https://angular.dev/tools/libraries/angular-package-format)."
+        },
+        {
+          "name": "breaking-change",
+          "comment": "13.0.0"
+        }
+      ],
+      "rawComment": "/**\n * A `HarnessEnvironment` implementation for Protractor.\n * @deprecated As of v13.0.0, this environment no longer works, as it is not\n * compatible with the new [Angular Package Format](https://angular.dev/tools/libraries/angular-package-format).\n * @breaking-change 13.0.0\n */",
+      "extends": "HarnessEnvironment<ElementFinder>",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/testing/protractor/protractor-harness-environment.ts",
+        "startLine": 34,
+        "endLine": 99
+      }
+    },
+    {
+      "name": "ProtractorElement",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "ElementFinder",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "ProtractorElement",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "blur",
+          "signatures": [
+            {
+              "name": "blur",
+              "entryType": "function",
+              "description": "Blur the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Blur the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "blur",
+            "description": "Blur the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Blur the element. */"
+          },
+          "entryType": "function",
+          "description": "Blur the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Blur the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "clear",
+          "signatures": [
+            {
+              "name": "clear",
+              "entryType": "function",
+              "description": "Clear the element's input (for input and textarea elements only).",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Clear the element's input (for input and textarea elements only). */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "clear",
+            "description": "Clear the element's input (for input and textarea elements only).",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Clear the element's input (for input and textarea elements only). */"
+          },
+          "entryType": "function",
+          "description": "Clear the element's input (for input and textarea elements only).",
+          "jsdocTags": [],
+          "rawComment": "/** Clear the element's input (for input and textarea elements only). */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "click",
+          "signatures": [
+            {
+              "name": "click",
+              "entryType": "function",
+              "description": "Click the element at the default location for the current environment. If you need to guarantee\nthe element is clicked at a specific location, consider using `click('center')` or\n`click(x, y)` instead.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "modifiers",
+                  "description": "",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Click the element at the default location for the current environment. If you need to guarantee\n   * the element is clicked at a specific location, consider using `click('center')` or\n   * `click(x, y)` instead.\n   */",
+              "returnType": "Promise<void>"
+            },
+            {
+              "name": "click",
+              "entryType": "function",
+              "description": "Click the element at the element's center.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "location",
+                  "description": "",
+                  "type": "\"center\"",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "modifiers",
+                  "description": "",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Click the element at the element's center. */",
+              "returnType": "Promise<void>"
+            },
+            {
+              "name": "click",
+              "entryType": "function",
+              "description": "Click the element at the specified coordinates relative to the top-left of the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the X-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the Y-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Modifier keys held while clicking"
+                }
+              ],
+              "params": [
+                {
+                  "name": "relativeX",
+                  "description": "Coordinate within the element, along the X-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "relativeY",
+                  "description": "Coordinate within the element, along the Y-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "modifiers",
+                  "description": "Modifier keys held while clicking",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Click the element at the specified coordinates relative to the top-left of the element.\n   * @param relativeX Coordinate within the element, along the X-axis at which to click.\n   * @param relativeY Coordinate within the element, along the Y-axis at which to click.\n   * @param modifiers Modifier keys held while clicking\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "args",
+                "description": "",
+                "type": "[any?] | [\"center\", any?] | [number, number, any?]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "click",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "rightClick",
+          "signatures": [
+            {
+              "name": "rightClick",
+              "entryType": "function",
+              "description": "Right clicks on the element at the specified coordinates relative to the top-left of it.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the X-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the Y-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Modifier keys held while clicking"
+                }
+              ],
+              "params": [
+                {
+                  "name": "relativeX",
+                  "description": "Coordinate within the element, along the X-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "relativeY",
+                  "description": "Coordinate within the element, along the Y-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "modifiers",
+                  "description": "Modifier keys held while clicking",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Right clicks on the element at the specified coordinates relative to the top-left of it.\n   * @param relativeX Coordinate within the element, along the X-axis at which to click.\n   * @param relativeY Coordinate within the element, along the Y-axis at which to click.\n   * @param modifiers Modifier keys held while clicking\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "args",
+                "description": "",
+                "type": "[any?] | [\"center\", any?] | [number, number, any?]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "rightClick",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "focus",
+          "signatures": [
+            {
+              "name": "focus",
+              "entryType": "function",
+              "description": "Focus the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Focus the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "focus",
+            "description": "Focus the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Focus the element. */"
+          },
+          "entryType": "function",
+          "description": "Focus the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Focus the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getCssValue",
+          "signatures": [
+            {
+              "name": "getCssValue",
+              "entryType": "function",
+              "description": "Get the computed value of the given CSS property for the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "property",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Get the computed value of the given CSS property for the element. */",
+              "returnType": "Promise<string>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "property",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<string>",
+            "generics": [],
+            "name": "getCssValue",
+            "description": "Get the computed value of the given CSS property for the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Get the computed value of the given CSS property for the element. */"
+          },
+          "entryType": "function",
+          "description": "Get the computed value of the given CSS property for the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Get the computed value of the given CSS property for the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "hover",
+          "signatures": [
+            {
+              "name": "hover",
+              "entryType": "function",
+              "description": "Hovers the mouse over the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Hovers the mouse over the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "hover",
+            "description": "Hovers the mouse over the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Hovers the mouse over the element. */"
+          },
+          "entryType": "function",
+          "description": "Hovers the mouse over the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Hovers the mouse over the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "mouseAway",
+          "signatures": [
+            {
+              "name": "mouseAway",
+              "entryType": "function",
+              "description": "Moves the mouse away from the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Moves the mouse away from the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "mouseAway",
+            "description": "Moves the mouse away from the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Moves the mouse away from the element. */"
+          },
+          "entryType": "function",
+          "description": "Moves the mouse away from the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Moves the mouse away from the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "sendKeys",
+          "signatures": [
+            {
+              "name": "sendKeys",
+              "entryType": "function",
+              "description": "Sends the given string to the input as a series of key presses. Also fires input events\nand attempts to add the string to the Element's value.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "keys",
+                  "description": "",
+                  "type": "any[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "rawComment": "/**\n   * Sends the given string to the input as a series of key presses. Also fires input events\n   * and attempts to add the string to the Element's value.\n   */",
+              "returnType": "Promise<void>"
+            },
+            {
+              "name": "sendKeys",
+              "entryType": "function",
+              "description": "Sends the given string to the input as a series of key presses. Also fires input events\nand attempts to add the string to the Element's value.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "modifiers",
+                  "description": "",
+                  "type": "ModifierKeys",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "keys",
+                  "description": "",
+                  "type": "any[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "rawComment": "/**\n   * Sends the given string to the input as a series of key presses. Also fires input events\n   * and attempts to add the string to the Element's value.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "modifiersAndKeys",
+                "description": "",
+                "type": "any[]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "sendKeys",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "text",
+          "signatures": [
+            {
+              "name": "text",
+              "entryType": "function",
+              "description": "Gets the text from the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Options that affect what text is included."
+                }
+              ],
+              "params": [
+                {
+                  "name": "options",
+                  "description": "Options that affect what text is included.",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */",
+              "returnType": "Promise<string>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "options",
+                "description": "Options that affect what text is included.",
+                "type": "any",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<string>",
+            "generics": [],
+            "name": "text",
+            "description": "Gets the text from the element.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Options that affect what text is included."
+              }
+            ],
+            "rawComment": "/**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets the text from the element.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Options that affect what text is included."
+            }
+          ],
+          "rawComment": "/**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "setContenteditableValue",
+          "signatures": [
+            {
+              "name": "setContenteditableValue",
+              "entryType": "function",
+              "description": "Sets the value of a `contenteditable` element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Value to be set on the element."
+                }
+              ],
+              "params": [
+                {
+                  "name": "value",
+                  "description": "Value to be set on the element.",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets the value of a `contenteditable` element.\n   * @param value Value to be set on the element.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "value",
+                "description": "Value to be set on the element.",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "setContenteditableValue",
+            "description": "Sets the value of a `contenteditable` element.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Value to be set on the element."
+              }
+            ],
+            "rawComment": "/**\n   * Sets the value of a `contenteditable` element.\n   * @param value Value to be set on the element.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets the value of a `contenteditable` element.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Value to be set on the element."
+            }
+          ],
+          "rawComment": "/**\n   * Sets the value of a `contenteditable` element.\n   * @param value Value to be set on the element.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getAttribute",
+          "signatures": [
+            {
+              "name": "getAttribute",
+              "entryType": "function",
+              "description": "Gets the value for the given attribute from the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Gets the value for the given attribute from the element. */",
+              "returnType": "Promise<string | null>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<string | null>",
+            "generics": [],
+            "name": "getAttribute",
+            "description": "Gets the value for the given attribute from the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the value for the given attribute from the element. */"
+          },
+          "entryType": "function",
+          "description": "Gets the value for the given attribute from the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the value for the given attribute from the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "hasClass",
+          "signatures": [
+            {
+              "name": "hasClass",
+              "entryType": "function",
+              "description": "Checks whether the element has the given class.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Checks whether the element has the given class. */",
+              "returnType": "Promise<boolean>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<boolean>",
+            "generics": [],
+            "name": "hasClass",
+            "description": "Checks whether the element has the given class.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Checks whether the element has the given class. */"
+          },
+          "entryType": "function",
+          "description": "Checks whether the element has the given class.",
+          "jsdocTags": [],
+          "rawComment": "/** Checks whether the element has the given class. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getDimensions",
+          "signatures": [
+            {
+              "name": "getDimensions",
+              "entryType": "function",
+              "description": "Gets the dimensions of the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Gets the dimensions of the element. */",
+              "returnType": "Promise<ElementDimensions>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<ElementDimensions>",
+            "generics": [],
+            "name": "getDimensions",
+            "description": "Gets the dimensions of the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the dimensions of the element. */"
+          },
+          "entryType": "function",
+          "description": "Gets the dimensions of the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the dimensions of the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getProperty",
+          "signatures": [
+            {
+              "name": "getProperty",
+              "entryType": "function",
+              "description": "Gets the value of a property of an element.",
+              "generics": [
+                {
+                  "name": "T",
+                  "default": "any"
+                }
+              ],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Gets the value of a property of an element. */",
+              "returnType": "Promise<T>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<T>",
+            "generics": [
+              {
+                "name": "T",
+                "default": "any"
+              }
+            ],
+            "name": "getProperty",
+            "description": "Gets the value of a property of an element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the value of a property of an element. */"
+          },
+          "entryType": "function",
+          "description": "Gets the value of a property of an element.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the value of a property of an element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "setInputValue",
+          "signatures": [
+            {
+              "name": "setInputValue",
+              "entryType": "function",
+              "description": "Sets the value of a property of an input.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "value",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Sets the value of a property of an input. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "value",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "setInputValue",
+            "description": "Sets the value of a property of an input.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Sets the value of a property of an input. */"
+          },
+          "entryType": "function",
+          "description": "Sets the value of a property of an input.",
+          "jsdocTags": [],
+          "rawComment": "/** Sets the value of a property of an input. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "selectOptions",
+          "signatures": [
+            {
+              "name": "selectOptions",
+              "entryType": "function",
+              "description": "Selects the options at the specified indexes inside of a native `select` element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "optionIndexes",
+                  "description": "",
+                  "type": "number[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "rawComment": "/** Selects the options at the specified indexes inside of a native `select` element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "optionIndexes",
+                "description": "",
+                "type": "number[]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "selectOptions",
+            "description": "Selects the options at the specified indexes inside of a native `select` element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Selects the options at the specified indexes inside of a native `select` element. */"
+          },
+          "entryType": "function",
+          "description": "Selects the options at the specified indexes inside of a native `select` element.",
+          "jsdocTags": [],
+          "rawComment": "/** Selects the options at the specified indexes inside of a native `select` element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "matchesSelector",
+          "signatures": [
+            {
+              "name": "matchesSelector",
+              "entryType": "function",
+              "description": "Checks whether this element matches the given selector.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "selector",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Checks whether this element matches the given selector. */",
+              "returnType": "Promise<boolean>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "selector",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<boolean>",
+            "generics": [],
+            "name": "matchesSelector",
+            "description": "Checks whether this element matches the given selector.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Checks whether this element matches the given selector. */"
+          },
+          "entryType": "function",
+          "description": "Checks whether this element matches the given selector.",
+          "jsdocTags": [],
+          "rawComment": "/** Checks whether this element matches the given selector. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "isFocused",
+          "signatures": [
+            {
+              "name": "isFocused",
+              "entryType": "function",
+              "description": "Checks whether the element is focused.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Checks whether the element is focused. */",
+              "returnType": "Promise<boolean>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<boolean>",
+            "generics": [],
+            "name": "isFocused",
+            "description": "Checks whether the element is focused.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Checks whether the element is focused. */"
+          },
+          "entryType": "function",
+          "description": "Checks whether the element is focused.",
+          "jsdocTags": [],
+          "rawComment": "/** Checks whether the element is focused. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "dispatchEvent",
+          "signatures": [
+            {
+              "name": "dispatchEvent",
+              "entryType": "function",
+              "description": "Dispatches an event with a particular name.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Name of the event to be dispatched."
+                }
+              ],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "Name of the event to be dispatched.",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "data",
+                  "description": "",
+                  "type": "Record<string, EventData> | undefined",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "Name of the event to be dispatched.",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "data",
+                "description": "",
+                "type": "Record<string, EventData> | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "dispatchEvent",
+            "description": "Dispatches an event with a particular name.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Name of the event to be dispatched."
+              }
+            ],
+            "rawComment": "/**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */"
+          },
+          "entryType": "function",
+          "description": "Dispatches an event with a particular name.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Name of the event to be dispatched."
+            }
+          ],
+          "rawComment": "/**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [],
+      "description": "A `TestElement` implementation for Protractor.",
+      "jsdocTags": [
+        {
+          "name": "deprecated",
+          "comment": ""
+        },
+        {
+          "name": "breaking-change",
+          "comment": "13.0.0"
+        }
+      ],
+      "rawComment": "/**\n * A `TestElement` implementation for Protractor.\n * @deprecated\n * @breaking-change 13.0.0\n */",
+      "implements": [
+        "TestElement"
+      ],
+      "source": {
+        "filePath": "/src/cdk/testing/protractor/protractor-element.ts",
+        "startLine": 79,
+        "endLine": 330
+      }
+    }
+  ],
+  "symbols": [
+    [
+      "ProtractorHarnessEnvironmentOptions",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironmentOptions",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironmentOptions.queryFn",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment.constructor",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment.forceStabilize",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment.waitForTasksOutsideAngular",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment.getDocumentRoot",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment.createTestElement",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment.createEnvironment",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment.getAllRawElements",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment.loader",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorHarnessEnvironment.getNativeElement",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.constructor",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.blur",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.clear",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.click",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.rightClick",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.focus",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.getCssValue",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.hover",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.mouseAway",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.sendKeys",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.text",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.setContenteditableValue",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.getAttribute",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.hasClass",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.getDimensions",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.getProperty",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.setInputValue",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.selectOptions",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.matchesSelector",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.isFocused",
+      "@angular/cdk/testing/protractor"
+    ],
+    [
+      "ProtractorElement.dispatchEvent",
+      "@angular/cdk/testing/protractor"
+    ]
+  ]
+}

node_modules/@angular/cdk/_adev_assets/cdk_testing_selenium_webdriver.json

@@ -0,0 +1,1801 @@
+{
+  "repo": "angular/components",
+  "moduleLabel": "@angular/cdk/testing/selenium-webdriver",
+  "moduleName": "@angular/cdk/testing/selenium-webdriver",
+  "normalizedModuleName": "angular_cdk_testing_selenium-webdriver",
+  "entries": [
+    {
+      "name": "SeleniumWebDriverElement",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "() => webdriver.WebElement",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_stabilize",
+                "description": "",
+                "type": "() => Promise<void>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "SeleniumWebDriverElement",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "blur",
+          "signatures": [
+            {
+              "name": "blur",
+              "entryType": "function",
+              "description": "Blur the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Blur the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "blur",
+            "description": "Blur the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Blur the element. */"
+          },
+          "entryType": "function",
+          "description": "Blur the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Blur the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "clear",
+          "signatures": [
+            {
+              "name": "clear",
+              "entryType": "function",
+              "description": "Clear the element's input (for input and textarea elements only).",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Clear the element's input (for input and textarea elements only). */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "clear",
+            "description": "Clear the element's input (for input and textarea elements only).",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Clear the element's input (for input and textarea elements only). */"
+          },
+          "entryType": "function",
+          "description": "Clear the element's input (for input and textarea elements only).",
+          "jsdocTags": [],
+          "rawComment": "/** Clear the element's input (for input and textarea elements only). */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "click",
+          "signatures": [
+            {
+              "name": "click",
+              "entryType": "function",
+              "description": "Click the element at the default location for the current environment. If you need to guarantee\nthe element is clicked at a specific location, consider using `click('center')` or\n`click(x, y)` instead.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "modifiers",
+                  "description": "",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Click the element at the default location for the current environment. If you need to guarantee\n   * the element is clicked at a specific location, consider using `click('center')` or\n   * `click(x, y)` instead.\n   */",
+              "returnType": "Promise<void>"
+            },
+            {
+              "name": "click",
+              "entryType": "function",
+              "description": "Click the element at the element's center.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "location",
+                  "description": "",
+                  "type": "\"center\"",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "modifiers",
+                  "description": "",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Click the element at the element's center. */",
+              "returnType": "Promise<void>"
+            },
+            {
+              "name": "click",
+              "entryType": "function",
+              "description": "Click the element at the specified coordinates relative to the top-left of the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the X-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the Y-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Modifier keys held while clicking"
+                }
+              ],
+              "params": [
+                {
+                  "name": "relativeX",
+                  "description": "Coordinate within the element, along the X-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "relativeY",
+                  "description": "Coordinate within the element, along the Y-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "modifiers",
+                  "description": "Modifier keys held while clicking",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Click the element at the specified coordinates relative to the top-left of the element.\n   * @param relativeX Coordinate within the element, along the X-axis at which to click.\n   * @param relativeY Coordinate within the element, along the Y-axis at which to click.\n   * @param modifiers Modifier keys held while clicking\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "args",
+                "description": "",
+                "type": "[any?] | [\"center\", any?] | [number, number, any?]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "click",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "rightClick",
+          "signatures": [
+            {
+              "name": "rightClick",
+              "entryType": "function",
+              "description": "Right clicks on the element at the specified coordinates relative to the top-left of it.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the X-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the Y-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Modifier keys held while clicking"
+                }
+              ],
+              "params": [
+                {
+                  "name": "relativeX",
+                  "description": "Coordinate within the element, along the X-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "relativeY",
+                  "description": "Coordinate within the element, along the Y-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "modifiers",
+                  "description": "Modifier keys held while clicking",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Right clicks on the element at the specified coordinates relative to the top-left of it.\n   * @param relativeX Coordinate within the element, along the X-axis at which to click.\n   * @param relativeY Coordinate within the element, along the Y-axis at which to click.\n   * @param modifiers Modifier keys held while clicking\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "args",
+                "description": "",
+                "type": "[any?] | [\"center\", any?] | [number, number, any?]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "rightClick",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "focus",
+          "signatures": [
+            {
+              "name": "focus",
+              "entryType": "function",
+              "description": "Focus the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Focus the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "focus",
+            "description": "Focus the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Focus the element. */"
+          },
+          "entryType": "function",
+          "description": "Focus the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Focus the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getCssValue",
+          "signatures": [
+            {
+              "name": "getCssValue",
+              "entryType": "function",
+              "description": "Get the computed value of the given CSS property for the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "property",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Get the computed value of the given CSS property for the element. */",
+              "returnType": "Promise<string>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "property",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<string>",
+            "generics": [],
+            "name": "getCssValue",
+            "description": "Get the computed value of the given CSS property for the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Get the computed value of the given CSS property for the element. */"
+          },
+          "entryType": "function",
+          "description": "Get the computed value of the given CSS property for the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Get the computed value of the given CSS property for the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "hover",
+          "signatures": [
+            {
+              "name": "hover",
+              "entryType": "function",
+              "description": "Hovers the mouse over the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Hovers the mouse over the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "hover",
+            "description": "Hovers the mouse over the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Hovers the mouse over the element. */"
+          },
+          "entryType": "function",
+          "description": "Hovers the mouse over the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Hovers the mouse over the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "mouseAway",
+          "signatures": [
+            {
+              "name": "mouseAway",
+              "entryType": "function",
+              "description": "Moves the mouse away from the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Moves the mouse away from the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "mouseAway",
+            "description": "Moves the mouse away from the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Moves the mouse away from the element. */"
+          },
+          "entryType": "function",
+          "description": "Moves the mouse away from the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Moves the mouse away from the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "sendKeys",
+          "signatures": [
+            {
+              "name": "sendKeys",
+              "entryType": "function",
+              "description": "Sends the given string to the input as a series of key presses. Also fires input events\nand attempts to add the string to the Element's value.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "keys",
+                  "description": "",
+                  "type": "any[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "rawComment": "/**\n   * Sends the given string to the input as a series of key presses. Also fires input events\n   * and attempts to add the string to the Element's value.\n   */",
+              "returnType": "Promise<void>"
+            },
+            {
+              "name": "sendKeys",
+              "entryType": "function",
+              "description": "Sends the given string to the input as a series of key presses. Also fires input events\nand attempts to add the string to the Element's value.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "modifiers",
+                  "description": "",
+                  "type": "ModifierKeys",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "keys",
+                  "description": "",
+                  "type": "any[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "rawComment": "/**\n   * Sends the given string to the input as a series of key presses. Also fires input events\n   * and attempts to add the string to the Element's value.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "modifiersAndKeys",
+                "description": "",
+                "type": "any[]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "sendKeys",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "text",
+          "signatures": [
+            {
+              "name": "text",
+              "entryType": "function",
+              "description": "Gets the text from the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Options that affect what text is included."
+                }
+              ],
+              "params": [
+                {
+                  "name": "options",
+                  "description": "Options that affect what text is included.",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */",
+              "returnType": "Promise<string>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "options",
+                "description": "Options that affect what text is included.",
+                "type": "any",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<string>",
+            "generics": [],
+            "name": "text",
+            "description": "Gets the text from the element.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Options that affect what text is included."
+              }
+            ],
+            "rawComment": "/**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets the text from the element.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Options that affect what text is included."
+            }
+          ],
+          "rawComment": "/**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "setContenteditableValue",
+          "signatures": [
+            {
+              "name": "setContenteditableValue",
+              "entryType": "function",
+              "description": "Sets the value of a `contenteditable` element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Value to be set on the element."
+                }
+              ],
+              "params": [
+                {
+                  "name": "value",
+                  "description": "Value to be set on the element.",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets the value of a `contenteditable` element.\n   * @param value Value to be set on the element.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "value",
+                "description": "Value to be set on the element.",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "setContenteditableValue",
+            "description": "Sets the value of a `contenteditable` element.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Value to be set on the element."
+              }
+            ],
+            "rawComment": "/**\n   * Sets the value of a `contenteditable` element.\n   * @param value Value to be set on the element.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets the value of a `contenteditable` element.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Value to be set on the element."
+            }
+          ],
+          "rawComment": "/**\n   * Sets the value of a `contenteditable` element.\n   * @param value Value to be set on the element.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getAttribute",
+          "signatures": [
+            {
+              "name": "getAttribute",
+              "entryType": "function",
+              "description": "Gets the value for the given attribute from the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Gets the value for the given attribute from the element. */",
+              "returnType": "Promise<string | null>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<string | null>",
+            "generics": [],
+            "name": "getAttribute",
+            "description": "Gets the value for the given attribute from the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the value for the given attribute from the element. */"
+          },
+          "entryType": "function",
+          "description": "Gets the value for the given attribute from the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the value for the given attribute from the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "hasClass",
+          "signatures": [
+            {
+              "name": "hasClass",
+              "entryType": "function",
+              "description": "Checks whether the element has the given class.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Checks whether the element has the given class. */",
+              "returnType": "Promise<boolean>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<boolean>",
+            "generics": [],
+            "name": "hasClass",
+            "description": "Checks whether the element has the given class.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Checks whether the element has the given class. */"
+          },
+          "entryType": "function",
+          "description": "Checks whether the element has the given class.",
+          "jsdocTags": [],
+          "rawComment": "/** Checks whether the element has the given class. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getDimensions",
+          "signatures": [
+            {
+              "name": "getDimensions",
+              "entryType": "function",
+              "description": "Gets the dimensions of the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Gets the dimensions of the element. */",
+              "returnType": "Promise<ElementDimensions>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<ElementDimensions>",
+            "generics": [],
+            "name": "getDimensions",
+            "description": "Gets the dimensions of the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the dimensions of the element. */"
+          },
+          "entryType": "function",
+          "description": "Gets the dimensions of the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the dimensions of the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getProperty",
+          "signatures": [
+            {
+              "name": "getProperty",
+              "entryType": "function",
+              "description": "Gets the value of a property of an element.",
+              "generics": [
+                {
+                  "name": "T",
+                  "default": "any"
+                }
+              ],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Gets the value of a property of an element. */",
+              "returnType": "Promise<T>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<T>",
+            "generics": [
+              {
+                "name": "T",
+                "default": "any"
+              }
+            ],
+            "name": "getProperty",
+            "description": "Gets the value of a property of an element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the value of a property of an element. */"
+          },
+          "entryType": "function",
+          "description": "Gets the value of a property of an element.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the value of a property of an element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "setInputValue",
+          "signatures": [
+            {
+              "name": "setInputValue",
+              "entryType": "function",
+              "description": "Sets the value of a property of an input.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "newValue",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Sets the value of a property of an input. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "newValue",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "setInputValue",
+            "description": "Sets the value of a property of an input.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Sets the value of a property of an input. */"
+          },
+          "entryType": "function",
+          "description": "Sets the value of a property of an input.",
+          "jsdocTags": [],
+          "rawComment": "/** Sets the value of a property of an input. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "selectOptions",
+          "signatures": [
+            {
+              "name": "selectOptions",
+              "entryType": "function",
+              "description": "Selects the options at the specified indexes inside of a native `select` element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "optionIndexes",
+                  "description": "",
+                  "type": "number[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "rawComment": "/** Selects the options at the specified indexes inside of a native `select` element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "optionIndexes",
+                "description": "",
+                "type": "number[]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "selectOptions",
+            "description": "Selects the options at the specified indexes inside of a native `select` element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Selects the options at the specified indexes inside of a native `select` element. */"
+          },
+          "entryType": "function",
+          "description": "Selects the options at the specified indexes inside of a native `select` element.",
+          "jsdocTags": [],
+          "rawComment": "/** Selects the options at the specified indexes inside of a native `select` element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "matchesSelector",
+          "signatures": [
+            {
+              "name": "matchesSelector",
+              "entryType": "function",
+              "description": "Checks whether this element matches the given selector.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "selector",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Checks whether this element matches the given selector. */",
+              "returnType": "Promise<boolean>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "selector",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<boolean>",
+            "generics": [],
+            "name": "matchesSelector",
+            "description": "Checks whether this element matches the given selector.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Checks whether this element matches the given selector. */"
+          },
+          "entryType": "function",
+          "description": "Checks whether this element matches the given selector.",
+          "jsdocTags": [],
+          "rawComment": "/** Checks whether this element matches the given selector. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "isFocused",
+          "signatures": [
+            {
+              "name": "isFocused",
+              "entryType": "function",
+              "description": "Checks whether the element is focused.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Checks whether the element is focused. */",
+              "returnType": "Promise<boolean>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<boolean>",
+            "generics": [],
+            "name": "isFocused",
+            "description": "Checks whether the element is focused.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Checks whether the element is focused. */"
+          },
+          "entryType": "function",
+          "description": "Checks whether the element is focused.",
+          "jsdocTags": [],
+          "rawComment": "/** Checks whether the element is focused. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "dispatchEvent",
+          "signatures": [
+            {
+              "name": "dispatchEvent",
+              "entryType": "function",
+              "description": "Dispatches an event with a particular name.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Name of the event to be dispatched."
+                }
+              ],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "Name of the event to be dispatched.",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "data",
+                  "description": "",
+                  "type": "Record<string, EventData> | undefined",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "Name of the event to be dispatched.",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "data",
+                "description": "",
+                "type": "Record<string, EventData> | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "dispatchEvent",
+            "description": "Dispatches an event with a particular name.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Name of the event to be dispatched."
+              }
+            ],
+            "rawComment": "/**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */"
+          },
+          "entryType": "function",
+          "description": "Dispatches an event with a particular name.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Name of the event to be dispatched."
+            }
+          ],
+          "rawComment": "/**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [],
+      "description": "A `TestElement` implementation for WebDriver.",
+      "jsdocTags": [],
+      "rawComment": "/** A `TestElement` implementation for WebDriver. */",
+      "implements": [
+        "TestElement"
+      ],
+      "source": {
+        "filePath": "/src/cdk/testing/selenium-webdriver/selenium-web-driver-element.ts",
+        "startLine": 17,
+        "endLine": 318
+      }
+    },
+    {
+      "name": "WebDriverHarnessEnvironmentOptions",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "queryFn",
+          "type": "(selector: string, root: () => webdriver.WebElement) => Promise<webdriver.WebElement[]>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "The query function used to find DOM elements.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [],
+      "description": "Options to configure the environment.",
+      "jsdocTags": [],
+      "rawComment": "/** Options to configure the environment. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/testing/selenium-webdriver/selenium-web-driver-harness-environment.ts",
+        "startLine": 35,
+        "endLine": 38
+      }
+    },
+    {
+      "name": "waitForAngularReady",
+      "signatures": [
+        {
+          "name": "waitForAngularReady",
+          "entryType": "function",
+          "description": "Waits for angular to be ready after the page load.",
+          "generics": [],
+          "isNewType": false,
+          "jsdocTags": [],
+          "params": [
+            {
+              "name": "wd",
+              "description": "",
+              "type": "webdriver.WebDriver",
+              "isOptional": false,
+              "isRestParam": false
+            }
+          ],
+          "rawComment": "/** Waits for angular to be ready after the page load. */",
+          "returnType": "Promise<void>"
+        }
+      ],
+      "implementation": {
+        "params": [
+          {
+            "name": "wd",
+            "description": "",
+            "type": "webdriver.WebDriver",
+            "isOptional": false,
+            "isRestParam": false
+          }
+        ],
+        "isNewType": false,
+        "returnType": "Promise<void>",
+        "generics": [],
+        "name": "waitForAngularReady",
+        "description": "Waits for angular to be ready after the page load.",
+        "entryType": "function",
+        "jsdocTags": [],
+        "rawComment": "/** Waits for angular to be ready after the page load. */"
+      },
+      "entryType": "function",
+      "description": "Waits for angular to be ready after the page load.",
+      "jsdocTags": [],
+      "rawComment": "/** Waits for angular to be ready after the page load. */",
+      "source": {
+        "filePath": "/src/cdk/testing/selenium-webdriver/selenium-web-driver-harness-environment.ts",
+        "startLine": 65,
+        "endLine": 68
+      }
+    },
+    {
+      "name": "SeleniumWebDriverHarnessEnvironment",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [],
+          "implementation": {
+            "params": [
+              {
+                "name": "rawRootElement",
+                "description": "",
+                "type": "() => webdriver.WebElement",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "options",
+                "description": "",
+                "type": "WebDriverHarnessEnvironmentOptions | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "SeleniumWebDriverHarnessEnvironment",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "forceStabilize",
+          "signatures": [
+            {
+              "name": "forceStabilize",
+              "entryType": "function",
+              "description": "Flushes change detection and async tasks captured in the Angular zone.\nIn most cases it should not be necessary to call this manually. However, there may be some edge\ncases where it is needed to fully flush animation events.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "forceStabilize",
+            "description": "Flushes change detection and async tasks captured in the Angular zone.\nIn most cases it should not be necessary to call this manually. However, there may be some edge\ncases where it is needed to fully flush animation events.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */"
+          },
+          "entryType": "function",
+          "description": "Flushes change detection and async tasks captured in the Angular zone.\nIn most cases it should not be necessary to call this manually. However, there may be some edge\ncases where it is needed to fully flush animation events.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "waitForTasksOutsideAngular",
+          "signatures": [
+            {
+              "name": "waitForTasksOutsideAngular",
+              "entryType": "function",
+              "description": "",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "docs-private",
+                  "comment": ""
+                }
+              ],
+              "params": [],
+              "rawComment": "/** @docs-private */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "waitForTasksOutsideAngular",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "docs-private",
+                "comment": ""
+              }
+            ],
+            "rawComment": "/** @docs-private */"
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [
+            {
+              "name": "docs-private",
+              "comment": ""
+            }
+          ],
+          "rawComment": "/** @docs-private */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getDocumentRoot",
+          "signatures": [
+            {
+              "name": "getDocumentRoot",
+              "entryType": "function",
+              "description": "Gets the root element for the document.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Gets the root element for the document. */",
+              "returnType": "() => webdriver.WebElement"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "() => webdriver.WebElement",
+            "generics": [],
+            "name": "getDocumentRoot",
+            "description": "Gets the root element for the document.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the root element for the document. */"
+          },
+          "entryType": "function",
+          "description": "Gets the root element for the document.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the root element for the document. */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "createTestElement",
+          "signatures": [
+            {
+              "name": "createTestElement",
+              "entryType": "function",
+              "description": "Creates a `TestElement` from a raw element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "element",
+                  "description": "",
+                  "type": "() => webdriver.WebElement",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Creates a `TestElement` from a raw element. */",
+              "returnType": "TestElement"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "() => webdriver.WebElement",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "TestElement",
+            "generics": [],
+            "name": "createTestElement",
+            "description": "Creates a `TestElement` from a raw element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Creates a `TestElement` from a raw element. */"
+          },
+          "entryType": "function",
+          "description": "Creates a `TestElement` from a raw element.",
+          "jsdocTags": [],
+          "rawComment": "/** Creates a `TestElement` from a raw element. */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "createEnvironment",
+          "signatures": [
+            {
+              "name": "createEnvironment",
+              "entryType": "function",
+              "description": "Creates a `HarnessLoader` rooted at the given raw element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "element",
+                  "description": "",
+                  "type": "() => webdriver.WebElement",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Creates a `HarnessLoader` rooted at the given raw element. */",
+              "returnType": "HarnessEnvironment<() => webdriver.WebElement>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "() => webdriver.WebElement",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "HarnessEnvironment<() => webdriver.WebElement>",
+            "generics": [],
+            "name": "createEnvironment",
+            "description": "Creates a `HarnessLoader` rooted at the given raw element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Creates a `HarnessLoader` rooted at the given raw element. */"
+          },
+          "entryType": "function",
+          "description": "Creates a `HarnessLoader` rooted at the given raw element.",
+          "jsdocTags": [],
+          "rawComment": "/** Creates a `HarnessLoader` rooted at the given raw element. */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "getAllRawElements",
+          "signatures": [
+            {
+              "name": "getAllRawElements",
+              "entryType": "function",
+              "description": "Gets a list of all elements matching the given selector under this environment's root element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "selector",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */",
+              "returnType": "Promise<(() => webdriver.WebElement)[]>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "selector",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<(() => webdriver.WebElement)[]>",
+            "generics": [],
+            "name": "getAllRawElements",
+            "description": "Gets a list of all elements matching the given selector under this environment's root element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets a list of all elements matching the given selector under this environment's root element.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "getNativeElement",
+          "signatures": [
+            {
+              "name": "getNativeElement",
+              "entryType": "function",
+              "description": "Gets the ElementFinder corresponding to the given TestElement.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "el",
+                  "description": "",
+                  "type": "TestElement",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Gets the ElementFinder corresponding to the given TestElement. */",
+              "returnType": "webdriver.WebElement"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "el",
+                "description": "",
+                "type": "TestElement",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "webdriver.WebElement",
+            "generics": [],
+            "name": "getNativeElement",
+            "description": "Gets the ElementFinder corresponding to the given TestElement.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the ElementFinder corresponding to the given TestElement. */"
+          },
+          "entryType": "function",
+          "description": "Gets the ElementFinder corresponding to the given TestElement.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the ElementFinder corresponding to the given TestElement. */",
+          "memberType": "method",
+          "memberTags": [
+            "static"
+          ]
+        },
+        {
+          "name": "loader",
+          "signatures": [
+            {
+              "name": "loader",
+              "entryType": "function",
+              "description": "Creates a `HarnessLoader` rooted at the document root.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "driver",
+                  "description": "",
+                  "type": "webdriver.WebDriver",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "options",
+                  "description": "",
+                  "type": "WebDriverHarnessEnvironmentOptions | undefined",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Creates a `HarnessLoader` rooted at the document root. */",
+              "returnType": "HarnessLoader"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "driver",
+                "description": "",
+                "type": "webdriver.WebDriver",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "options",
+                "description": "",
+                "type": "WebDriverHarnessEnvironmentOptions | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "HarnessLoader",
+            "generics": [],
+            "name": "loader",
+            "description": "Creates a `HarnessLoader` rooted at the document root.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Creates a `HarnessLoader` rooted at the document root. */"
+          },
+          "entryType": "function",
+          "description": "Creates a `HarnessLoader` rooted at the document root.",
+          "jsdocTags": [],
+          "rawComment": "/** Creates a `HarnessLoader` rooted at the document root. */",
+          "memberType": "method",
+          "memberTags": [
+            "static"
+          ]
+        }
+      ],
+      "generics": [],
+      "description": "A `HarnessEnvironment` implementation for WebDriver.",
+      "jsdocTags": [],
+      "rawComment": "/** A `HarnessEnvironment` implementation for WebDriver. */",
+      "extends": "HarnessEnvironment<\n  () => webdriver.WebElement\n>",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/testing/selenium-webdriver/selenium-web-driver-harness-environment.ts",
+        "startLine": 71,
+        "endLine": 150
+      }
+    }
+  ],
+  "symbols": [
+    [
+      "SeleniumWebDriverElement",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "WebDriverHarnessEnvironmentOptions",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "waitForAngularReady",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.constructor",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.blur",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.clear",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.click",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.rightClick",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.focus",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.getCssValue",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.hover",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.mouseAway",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.sendKeys",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.text",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.setContenteditableValue",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.getAttribute",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.hasClass",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.getDimensions",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.getProperty",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.setInputValue",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.selectOptions",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.matchesSelector",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.isFocused",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverElement.dispatchEvent",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "WebDriverHarnessEnvironmentOptions",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "WebDriverHarnessEnvironmentOptions.queryFn",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "waitForAngularReady",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment.constructor",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment.forceStabilize",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment.waitForTasksOutsideAngular",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment.getDocumentRoot",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment.createTestElement",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment.createEnvironment",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment.getAllRawElements",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment.getNativeElement",
+      "@angular/cdk/testing/selenium-webdriver"
+    ],
+    [
+      "SeleniumWebDriverHarnessEnvironment.loader",
+      "@angular/cdk/testing/selenium-webdriver"
+    ]
+  ]
+}

node_modules/@angular/cdk/_adev_assets/cdk_testing_testbed.json

@@ -0,0 +1,1903 @@
+{
+  "repo": "angular/components",
+  "moduleLabel": "@angular/cdk/testing/testbed",
+  "moduleName": "@angular/cdk/testing/testbed",
+  "normalizedModuleName": "angular_cdk_testing_testbed",
+  "entries": [
+    {
+      "name": "TestbedHarnessEnvironmentOptions",
+      "isAbstract": false,
+      "entryType": "interface",
+      "members": [
+        {
+          "name": "queryFn",
+          "type": "(selector: string, root: Element) => Iterable<Element> | ArrayLike<Element>",
+          "memberType": "property",
+          "memberTags": [],
+          "description": "The query function used to find DOM elements.",
+          "jsdocTags": []
+        }
+      ],
+      "generics": [],
+      "description": "Options to configure the environment.",
+      "jsdocTags": [],
+      "rawComment": "/** Options to configure the environment. */",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/testing/testbed/testbed-harness-environment.ts",
+        "startLine": 25,
+        "endLine": 28
+      }
+    },
+    {
+      "name": "TestbedHarnessEnvironment",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [],
+          "implementation": {
+            "params": [
+              {
+                "name": "rawRootElement",
+                "description": "",
+                "type": "Element",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_fixture",
+                "description": "",
+                "type": "ComponentFixture<unknown>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "options",
+                "description": "",
+                "type": "TestbedHarnessEnvironmentOptions | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "TestbedHarnessEnvironment",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "forceStabilize",
+          "signatures": [
+            {
+              "name": "forceStabilize",
+              "entryType": "function",
+              "description": "Flushes change detection and async tasks captured in the Angular zone.\nIn most cases it should not be necessary to call this manually. However, there may be some edge\ncases where it is needed to fully flush animation events.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "forceStabilize",
+            "description": "Flushes change detection and async tasks captured in the Angular zone.\nIn most cases it should not be necessary to call this manually. However, there may be some edge\ncases where it is needed to fully flush animation events.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */"
+          },
+          "entryType": "function",
+          "description": "Flushes change detection and async tasks captured in the Angular zone.\nIn most cases it should not be necessary to call this manually. However, there may be some edge\ncases where it is needed to fully flush animation events.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "waitForTasksOutsideAngular",
+          "signatures": [
+            {
+              "name": "waitForTasksOutsideAngular",
+              "entryType": "function",
+              "description": "Waits for all scheduled or running async tasks to complete. This allows harness\nauthors to wait for async tasks outside of the Angular zone.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/**\n   * Waits for all scheduled or running async tasks to complete. This allows harness\n   * authors to wait for async tasks outside of the Angular zone.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "waitForTasksOutsideAngular",
+            "description": "Waits for all scheduled or running async tasks to complete. This allows harness\nauthors to wait for async tasks outside of the Angular zone.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Waits for all scheduled or running async tasks to complete. This allows harness\n   * authors to wait for async tasks outside of the Angular zone.\n   */"
+          },
+          "entryType": "function",
+          "description": "Waits for all scheduled or running async tasks to complete. This allows harness\nauthors to wait for async tasks outside of the Angular zone.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Waits for all scheduled or running async tasks to complete. This allows harness\n   * authors to wait for async tasks outside of the Angular zone.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getDocumentRoot",
+          "signatures": [
+            {
+              "name": "getDocumentRoot",
+              "entryType": "function",
+              "description": "Gets the root element for the document.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Gets the root element for the document. */",
+              "returnType": "Element"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Element",
+            "generics": [],
+            "name": "getDocumentRoot",
+            "description": "Gets the root element for the document.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the root element for the document. */"
+          },
+          "entryType": "function",
+          "description": "Gets the root element for the document.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the root element for the document. */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "createTestElement",
+          "signatures": [
+            {
+              "name": "createTestElement",
+              "entryType": "function",
+              "description": "Creates a `TestElement` from a raw element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "element",
+                  "description": "",
+                  "type": "Element",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Creates a `TestElement` from a raw element. */",
+              "returnType": "TestElement"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "Element",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "TestElement",
+            "generics": [],
+            "name": "createTestElement",
+            "description": "Creates a `TestElement` from a raw element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Creates a `TestElement` from a raw element. */"
+          },
+          "entryType": "function",
+          "description": "Creates a `TestElement` from a raw element.",
+          "jsdocTags": [],
+          "rawComment": "/** Creates a `TestElement` from a raw element. */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "createEnvironment",
+          "signatures": [
+            {
+              "name": "createEnvironment",
+              "entryType": "function",
+              "description": "Creates a `HarnessLoader` rooted at the given raw element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "element",
+                  "description": "",
+                  "type": "Element",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Creates a `HarnessLoader` rooted at the given raw element. */",
+              "returnType": "HarnessEnvironment<Element>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "Element",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "HarnessEnvironment<Element>",
+            "generics": [],
+            "name": "createEnvironment",
+            "description": "Creates a `HarnessLoader` rooted at the given raw element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Creates a `HarnessLoader` rooted at the given raw element. */"
+          },
+          "entryType": "function",
+          "description": "Creates a `HarnessLoader` rooted at the given raw element.",
+          "jsdocTags": [],
+          "rawComment": "/** Creates a `HarnessLoader` rooted at the given raw element. */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "getAllRawElements",
+          "signatures": [
+            {
+              "name": "getAllRawElements",
+              "entryType": "function",
+              "description": "Gets a list of all elements matching the given selector under this environment's root element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "selector",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */",
+              "returnType": "Promise<Element[]>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "selector",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<Element[]>",
+            "generics": [],
+            "name": "getAllRawElements",
+            "description": "Gets a list of all elements matching the given selector under this environment's root element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets a list of all elements matching the given selector under this environment's root element.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */",
+          "memberType": "method",
+          "memberTags": [
+            "protected"
+          ]
+        },
+        {
+          "name": "loader",
+          "signatures": [
+            {
+              "name": "loader",
+              "entryType": "function",
+              "description": "Creates a `HarnessLoader` rooted at the given fixture's root element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "fixture",
+                  "description": "",
+                  "type": "ComponentFixture<unknown>",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "options",
+                  "description": "",
+                  "type": "TestbedHarnessEnvironmentOptions | undefined",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Creates a `HarnessLoader` rooted at the given fixture's root element. */",
+              "returnType": "HarnessLoader"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "fixture",
+                "description": "",
+                "type": "ComponentFixture<unknown>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "options",
+                "description": "",
+                "type": "TestbedHarnessEnvironmentOptions | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "HarnessLoader",
+            "generics": [],
+            "name": "loader",
+            "description": "Creates a `HarnessLoader` rooted at the given fixture's root element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Creates a `HarnessLoader` rooted at the given fixture's root element. */"
+          },
+          "entryType": "function",
+          "description": "Creates a `HarnessLoader` rooted at the given fixture's root element.",
+          "jsdocTags": [],
+          "rawComment": "/** Creates a `HarnessLoader` rooted at the given fixture's root element. */",
+          "memberType": "method",
+          "memberTags": [
+            "static"
+          ]
+        },
+        {
+          "name": "documentRootLoader",
+          "signatures": [
+            {
+              "name": "documentRootLoader",
+              "entryType": "function",
+              "description": "Creates a `HarnessLoader` at the document root. This can be used if harnesses are\nlocated outside of a fixture (e.g. overlays appended to the document body).",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "fixture",
+                  "description": "",
+                  "type": "ComponentFixture<unknown>",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "options",
+                  "description": "",
+                  "type": "TestbedHarnessEnvironmentOptions | undefined",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Creates a `HarnessLoader` at the document root. This can be used if harnesses are\n   * located outside of a fixture (e.g. overlays appended to the document body).\n   */",
+              "returnType": "HarnessLoader"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "fixture",
+                "description": "",
+                "type": "ComponentFixture<unknown>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "options",
+                "description": "",
+                "type": "TestbedHarnessEnvironmentOptions | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "HarnessLoader",
+            "generics": [],
+            "name": "documentRootLoader",
+            "description": "Creates a `HarnessLoader` at the document root. This can be used if harnesses are\nlocated outside of a fixture (e.g. overlays appended to the document body).",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Creates a `HarnessLoader` at the document root. This can be used if harnesses are\n   * located outside of a fixture (e.g. overlays appended to the document body).\n   */"
+          },
+          "entryType": "function",
+          "description": "Creates a `HarnessLoader` at the document root. This can be used if harnesses are\nlocated outside of a fixture (e.g. overlays appended to the document body).",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Creates a `HarnessLoader` at the document root. This can be used if harnesses are\n   * located outside of a fixture (e.g. overlays appended to the document body).\n   */",
+          "memberType": "method",
+          "memberTags": [
+            "static"
+          ]
+        },
+        {
+          "name": "getNativeElement",
+          "signatures": [
+            {
+              "name": "getNativeElement",
+              "entryType": "function",
+              "description": "Gets the native DOM element corresponding to the given TestElement.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "el",
+                  "description": "",
+                  "type": "TestElement",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Gets the native DOM element corresponding to the given TestElement. */",
+              "returnType": "Element"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "el",
+                "description": "",
+                "type": "TestElement",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Element",
+            "generics": [],
+            "name": "getNativeElement",
+            "description": "Gets the native DOM element corresponding to the given TestElement.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the native DOM element corresponding to the given TestElement. */"
+          },
+          "entryType": "function",
+          "description": "Gets the native DOM element corresponding to the given TestElement.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the native DOM element corresponding to the given TestElement. */",
+          "memberType": "method",
+          "memberTags": [
+            "static"
+          ]
+        },
+        {
+          "name": "harnessForFixture",
+          "signatures": [
+            {
+              "name": "harnessForFixture",
+              "entryType": "function",
+              "description": "Creates an instance of the given harness type, using the fixture's root element as the\nharness's host element. This method should be used when creating a harness for the root element\nof a fixture, as components do not have the correct selector when they are created as the root\nof the fixture.",
+              "generics": [
+                {
+                  "name": "T",
+                  "constraint": "ComponentHarness"
+                }
+              ],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "fixture",
+                  "description": "",
+                  "type": "ComponentFixture<unknown>",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "harnessType",
+                  "description": "",
+                  "type": "ComponentHarnessConstructor<T>",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "options",
+                  "description": "",
+                  "type": "TestbedHarnessEnvironmentOptions | undefined",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Creates an instance of the given harness type, using the fixture's root element as the\n   * harness's host element. This method should be used when creating a harness for the root element\n   * of a fixture, as components do not have the correct selector when they are created as the root\n   * of the fixture.\n   */",
+              "returnType": "Promise<T>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "fixture",
+                "description": "",
+                "type": "ComponentFixture<unknown>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "harnessType",
+                "description": "",
+                "type": "ComponentHarnessConstructor<T>",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "options",
+                "description": "",
+                "type": "TestbedHarnessEnvironmentOptions | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<T>",
+            "generics": [
+              {
+                "name": "T",
+                "constraint": "ComponentHarness"
+              }
+            ],
+            "name": "harnessForFixture",
+            "description": "Creates an instance of the given harness type, using the fixture's root element as the\nharness's host element. This method should be used when creating a harness for the root element\nof a fixture, as components do not have the correct selector when they are created as the root\nof the fixture.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/**\n   * Creates an instance of the given harness type, using the fixture's root element as the\n   * harness's host element. This method should be used when creating a harness for the root element\n   * of a fixture, as components do not have the correct selector when they are created as the root\n   * of the fixture.\n   */"
+          },
+          "entryType": "function",
+          "description": "Creates an instance of the given harness type, using the fixture's root element as the\nharness's host element. This method should be used when creating a harness for the root element\nof a fixture, as components do not have the correct selector when they are created as the root\nof the fixture.",
+          "jsdocTags": [],
+          "rawComment": "/**\n   * Creates an instance of the given harness type, using the fixture's root element as the\n   * harness's host element. This method should be used when creating a harness for the root element\n   * of a fixture, as components do not have the correct selector when they are created as the root\n   * of the fixture.\n   */",
+          "memberType": "method",
+          "memberTags": [
+            "static"
+          ]
+        }
+      ],
+      "generics": [],
+      "description": "A `HarnessEnvironment` implementation for Angular's Testbed.",
+      "jsdocTags": [],
+      "rawComment": "/** A `HarnessEnvironment` implementation for Angular's Testbed. */",
+      "extends": "HarnessEnvironment<Element>",
+      "implements": [],
+      "source": {
+        "filePath": "/src/cdk/testing/testbed/testbed-harness-environment.ts",
+        "startLine": 89,
+        "endLine": 222
+      }
+    },
+    {
+      "name": "UnitTestElement",
+      "isAbstract": false,
+      "entryType": "undecorated_class",
+      "members": [
+        {
+          "name": "constructor",
+          "signatures": [],
+          "implementation": {
+            "params": [
+              {
+                "name": "element",
+                "description": "",
+                "type": "Element",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "_stabilize",
+                "description": "",
+                "type": "() => Promise<void>",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "UnitTestElement",
+            "generics": [],
+            "name": "constructor",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "blur",
+          "signatures": [
+            {
+              "name": "blur",
+              "entryType": "function",
+              "description": "Blur the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Blur the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "blur",
+            "description": "Blur the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Blur the element. */"
+          },
+          "entryType": "function",
+          "description": "Blur the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Blur the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "clear",
+          "signatures": [
+            {
+              "name": "clear",
+              "entryType": "function",
+              "description": "Clear the element's input (for input and textarea elements only).",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Clear the element's input (for input and textarea elements only). */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "clear",
+            "description": "Clear the element's input (for input and textarea elements only).",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Clear the element's input (for input and textarea elements only). */"
+          },
+          "entryType": "function",
+          "description": "Clear the element's input (for input and textarea elements only).",
+          "jsdocTags": [],
+          "rawComment": "/** Clear the element's input (for input and textarea elements only). */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "click",
+          "signatures": [
+            {
+              "name": "click",
+              "entryType": "function",
+              "description": "Click the element at the default location for the current environment. If you need to guarantee\nthe element is clicked at a specific location, consider using `click('center')` or\n`click(x, y)` instead.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "modifiers",
+                  "description": "",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Click the element at the default location for the current environment. If you need to guarantee\n   * the element is clicked at a specific location, consider using `click('center')` or\n   * `click(x, y)` instead.\n   */",
+              "returnType": "Promise<void>"
+            },
+            {
+              "name": "click",
+              "entryType": "function",
+              "description": "Click the element at the element's center.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "location",
+                  "description": "",
+                  "type": "\"center\"",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "modifiers",
+                  "description": "",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Click the element at the element's center. */",
+              "returnType": "Promise<void>"
+            },
+            {
+              "name": "click",
+              "entryType": "function",
+              "description": "Click the element at the specified coordinates relative to the top-left of the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the X-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the Y-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Modifier keys held while clicking"
+                }
+              ],
+              "params": [
+                {
+                  "name": "relativeX",
+                  "description": "Coordinate within the element, along the X-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "relativeY",
+                  "description": "Coordinate within the element, along the Y-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "modifiers",
+                  "description": "Modifier keys held while clicking",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Click the element at the specified coordinates relative to the top-left of the element.\n   * @param relativeX Coordinate within the element, along the X-axis at which to click.\n   * @param relativeY Coordinate within the element, along the Y-axis at which to click.\n   * @param modifiers Modifier keys held while clicking\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "args",
+                "description": "",
+                "type": "[any?] | [\"center\", any?] | [number, number, any?]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "click",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "rightClick",
+          "signatures": [
+            {
+              "name": "rightClick",
+              "entryType": "function",
+              "description": "Right clicks on the element at the specified coordinates relative to the top-left of it.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the X-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Coordinate within the element, along the Y-axis at which to click."
+                },
+                {
+                  "name": "param",
+                  "comment": "Modifier keys held while clicking"
+                }
+              ],
+              "params": [
+                {
+                  "name": "relativeX",
+                  "description": "Coordinate within the element, along the X-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "relativeY",
+                  "description": "Coordinate within the element, along the Y-axis at which to click.",
+                  "type": "number",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "modifiers",
+                  "description": "Modifier keys held while clicking",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Right clicks on the element at the specified coordinates relative to the top-left of it.\n   * @param relativeX Coordinate within the element, along the X-axis at which to click.\n   * @param relativeY Coordinate within the element, along the Y-axis at which to click.\n   * @param modifiers Modifier keys held while clicking\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "args",
+                "description": "",
+                "type": "[any?] | [\"center\", any?] | [number, number, any?]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "rightClick",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "focus",
+          "signatures": [
+            {
+              "name": "focus",
+              "entryType": "function",
+              "description": "Focus the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Focus the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "focus",
+            "description": "Focus the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Focus the element. */"
+          },
+          "entryType": "function",
+          "description": "Focus the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Focus the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getCssValue",
+          "signatures": [
+            {
+              "name": "getCssValue",
+              "entryType": "function",
+              "description": "Get the computed value of the given CSS property for the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "property",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Get the computed value of the given CSS property for the element. */",
+              "returnType": "Promise<string>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "property",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<string>",
+            "generics": [],
+            "name": "getCssValue",
+            "description": "Get the computed value of the given CSS property for the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Get the computed value of the given CSS property for the element. */"
+          },
+          "entryType": "function",
+          "description": "Get the computed value of the given CSS property for the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Get the computed value of the given CSS property for the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "hover",
+          "signatures": [
+            {
+              "name": "hover",
+              "entryType": "function",
+              "description": "Hovers the mouse over the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Hovers the mouse over the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "hover",
+            "description": "Hovers the mouse over the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Hovers the mouse over the element. */"
+          },
+          "entryType": "function",
+          "description": "Hovers the mouse over the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Hovers the mouse over the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "mouseAway",
+          "signatures": [
+            {
+              "name": "mouseAway",
+              "entryType": "function",
+              "description": "Moves the mouse away from the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Moves the mouse away from the element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "mouseAway",
+            "description": "Moves the mouse away from the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Moves the mouse away from the element. */"
+          },
+          "entryType": "function",
+          "description": "Moves the mouse away from the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Moves the mouse away from the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "sendKeys",
+          "signatures": [
+            {
+              "name": "sendKeys",
+              "entryType": "function",
+              "description": "Sends the given string to the input as a series of key presses. Also fires input events\nand attempts to add the string to the Element's value. Note that this cannot\nreproduce native browser behavior for keyboard shortcuts such as Tab, Ctrl + A, etc.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "keys",
+                  "description": "",
+                  "type": "any[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "rawComment": "/**\n   * Sends the given string to the input as a series of key presses. Also fires input events\n   * and attempts to add the string to the Element's value. Note that this cannot\n   * reproduce native browser behavior for keyboard shortcuts such as Tab, Ctrl + A, etc.\n   */",
+              "returnType": "Promise<void>"
+            },
+            {
+              "name": "sendKeys",
+              "entryType": "function",
+              "description": "Sends the given string to the input as a series of key presses. Also fires input events\nand attempts to add the string to the Element's value.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "modifiers",
+                  "description": "",
+                  "type": "ModifierKeys",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "keys",
+                  "description": "",
+                  "type": "any[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "rawComment": "/**\n   * Sends the given string to the input as a series of key presses. Also fires input events\n   * and attempts to add the string to the Element's value.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "modifiersAndKeys",
+                "description": "",
+                "type": "any[]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "sendKeys",
+            "description": "",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": ""
+          },
+          "entryType": "function",
+          "description": "",
+          "jsdocTags": [],
+          "rawComment": "",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "text",
+          "signatures": [
+            {
+              "name": "text",
+              "entryType": "function",
+              "description": "Gets the text from the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Options that affect what text is included."
+                }
+              ],
+              "params": [
+                {
+                  "name": "options",
+                  "description": "Options that affect what text is included.",
+                  "type": "any",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */",
+              "returnType": "Promise<string>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "options",
+                "description": "Options that affect what text is included.",
+                "type": "any",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<string>",
+            "generics": [],
+            "name": "text",
+            "description": "Gets the text from the element.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Options that affect what text is included."
+              }
+            ],
+            "rawComment": "/**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */"
+          },
+          "entryType": "function",
+          "description": "Gets the text from the element.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Options that affect what text is included."
+            }
+          ],
+          "rawComment": "/**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "setContenteditableValue",
+          "signatures": [
+            {
+              "name": "setContenteditableValue",
+              "entryType": "function",
+              "description": "Sets the value of a `contenteditable` element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Value to be set on the element."
+                }
+              ],
+              "params": [
+                {
+                  "name": "value",
+                  "description": "Value to be set on the element.",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Sets the value of a `contenteditable` element.\n   * @param value Value to be set on the element.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "value",
+                "description": "Value to be set on the element.",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "setContenteditableValue",
+            "description": "Sets the value of a `contenteditable` element.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Value to be set on the element."
+              }
+            ],
+            "rawComment": "/**\n   * Sets the value of a `contenteditable` element.\n   * @param value Value to be set on the element.\n   */"
+          },
+          "entryType": "function",
+          "description": "Sets the value of a `contenteditable` element.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Value to be set on the element."
+            }
+          ],
+          "rawComment": "/**\n   * Sets the value of a `contenteditable` element.\n   * @param value Value to be set on the element.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getAttribute",
+          "signatures": [
+            {
+              "name": "getAttribute",
+              "entryType": "function",
+              "description": "Gets the value for the given attribute from the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Gets the value for the given attribute from the element. */",
+              "returnType": "Promise<string | null>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<string | null>",
+            "generics": [],
+            "name": "getAttribute",
+            "description": "Gets the value for the given attribute from the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the value for the given attribute from the element. */"
+          },
+          "entryType": "function",
+          "description": "Gets the value for the given attribute from the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the value for the given attribute from the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "hasClass",
+          "signatures": [
+            {
+              "name": "hasClass",
+              "entryType": "function",
+              "description": "Checks whether the element has the given class.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Checks whether the element has the given class. */",
+              "returnType": "Promise<boolean>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<boolean>",
+            "generics": [],
+            "name": "hasClass",
+            "description": "Checks whether the element has the given class.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Checks whether the element has the given class. */"
+          },
+          "entryType": "function",
+          "description": "Checks whether the element has the given class.",
+          "jsdocTags": [],
+          "rawComment": "/** Checks whether the element has the given class. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getDimensions",
+          "signatures": [
+            {
+              "name": "getDimensions",
+              "entryType": "function",
+              "description": "Gets the dimensions of the element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Gets the dimensions of the element. */",
+              "returnType": "Promise<ElementDimensions>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<ElementDimensions>",
+            "generics": [],
+            "name": "getDimensions",
+            "description": "Gets the dimensions of the element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the dimensions of the element. */"
+          },
+          "entryType": "function",
+          "description": "Gets the dimensions of the element.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the dimensions of the element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "getProperty",
+          "signatures": [
+            {
+              "name": "getProperty",
+              "entryType": "function",
+              "description": "Gets the value of a property of an element.",
+              "generics": [
+                {
+                  "name": "T",
+                  "default": "any"
+                }
+              ],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Gets the value of a property of an element. */",
+              "returnType": "Promise<T>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<T>",
+            "generics": [
+              {
+                "name": "T",
+                "default": "any"
+              }
+            ],
+            "name": "getProperty",
+            "description": "Gets the value of a property of an element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Gets the value of a property of an element. */"
+          },
+          "entryType": "function",
+          "description": "Gets the value of a property of an element.",
+          "jsdocTags": [],
+          "rawComment": "/** Gets the value of a property of an element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "setInputValue",
+          "signatures": [
+            {
+              "name": "setInputValue",
+              "entryType": "function",
+              "description": "Sets the value of a property of an input.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "value",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Sets the value of a property of an input. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "value",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "setInputValue",
+            "description": "Sets the value of a property of an input.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Sets the value of a property of an input. */"
+          },
+          "entryType": "function",
+          "description": "Sets the value of a property of an input.",
+          "jsdocTags": [],
+          "rawComment": "/** Sets the value of a property of an input. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "selectOptions",
+          "signatures": [
+            {
+              "name": "selectOptions",
+              "entryType": "function",
+              "description": "Selects the options at the specified indexes inside of a native `select` element.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "optionIndexes",
+                  "description": "",
+                  "type": "number[]",
+                  "isOptional": false,
+                  "isRestParam": true
+                }
+              ],
+              "rawComment": "/** Selects the options at the specified indexes inside of a native `select` element. */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "optionIndexes",
+                "description": "",
+                "type": "number[]",
+                "isOptional": false,
+                "isRestParam": true
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "selectOptions",
+            "description": "Selects the options at the specified indexes inside of a native `select` element.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Selects the options at the specified indexes inside of a native `select` element. */"
+          },
+          "entryType": "function",
+          "description": "Selects the options at the specified indexes inside of a native `select` element.",
+          "jsdocTags": [],
+          "rawComment": "/** Selects the options at the specified indexes inside of a native `select` element. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "matchesSelector",
+          "signatures": [
+            {
+              "name": "matchesSelector",
+              "entryType": "function",
+              "description": "Checks whether this element matches the given selector.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [
+                {
+                  "name": "selector",
+                  "description": "",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/** Checks whether this element matches the given selector. */",
+              "returnType": "Promise<boolean>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "selector",
+                "description": "",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<boolean>",
+            "generics": [],
+            "name": "matchesSelector",
+            "description": "Checks whether this element matches the given selector.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Checks whether this element matches the given selector. */"
+          },
+          "entryType": "function",
+          "description": "Checks whether this element matches the given selector.",
+          "jsdocTags": [],
+          "rawComment": "/** Checks whether this element matches the given selector. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "isFocused",
+          "signatures": [
+            {
+              "name": "isFocused",
+              "entryType": "function",
+              "description": "Checks whether the element is focused.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [],
+              "params": [],
+              "rawComment": "/** Checks whether the element is focused. */",
+              "returnType": "Promise<boolean>"
+            }
+          ],
+          "implementation": {
+            "params": [],
+            "isNewType": false,
+            "returnType": "Promise<boolean>",
+            "generics": [],
+            "name": "isFocused",
+            "description": "Checks whether the element is focused.",
+            "entryType": "function",
+            "jsdocTags": [],
+            "rawComment": "/** Checks whether the element is focused. */"
+          },
+          "entryType": "function",
+          "description": "Checks whether the element is focused.",
+          "jsdocTags": [],
+          "rawComment": "/** Checks whether the element is focused. */",
+          "memberType": "method",
+          "memberTags": []
+        },
+        {
+          "name": "dispatchEvent",
+          "signatures": [
+            {
+              "name": "dispatchEvent",
+              "entryType": "function",
+              "description": "Dispatches an event with a particular name.",
+              "generics": [],
+              "isNewType": false,
+              "jsdocTags": [
+                {
+                  "name": "param",
+                  "comment": "Name of the event to be dispatched."
+                }
+              ],
+              "params": [
+                {
+                  "name": "name",
+                  "description": "Name of the event to be dispatched.",
+                  "type": "string",
+                  "isOptional": false,
+                  "isRestParam": false
+                },
+                {
+                  "name": "data",
+                  "description": "",
+                  "type": "Record<string, EventData> | undefined",
+                  "isOptional": true,
+                  "isRestParam": false
+                }
+              ],
+              "rawComment": "/**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */",
+              "returnType": "Promise<void>"
+            }
+          ],
+          "implementation": {
+            "params": [
+              {
+                "name": "name",
+                "description": "Name of the event to be dispatched.",
+                "type": "string",
+                "isOptional": false,
+                "isRestParam": false
+              },
+              {
+                "name": "data",
+                "description": "",
+                "type": "Record<string, EventData> | undefined",
+                "isOptional": true,
+                "isRestParam": false
+              }
+            ],
+            "isNewType": false,
+            "returnType": "Promise<void>",
+            "generics": [],
+            "name": "dispatchEvent",
+            "description": "Dispatches an event with a particular name.",
+            "entryType": "function",
+            "jsdocTags": [
+              {
+                "name": "param",
+                "comment": "Name of the event to be dispatched."
+              }
+            ],
+            "rawComment": "/**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */"
+          },
+          "entryType": "function",
+          "description": "Dispatches an event with a particular name.",
+          "jsdocTags": [
+            {
+              "name": "param",
+              "comment": "Name of the event to be dispatched."
+            }
+          ],
+          "rawComment": "/**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */",
+          "memberType": "method",
+          "memberTags": []
+        }
+      ],
+      "generics": [],
+      "description": "A `TestElement` implementation for unit tests.",
+      "jsdocTags": [],
+      "rawComment": "/** A `TestElement` implementation for unit tests. */",
+      "implements": [
+        "TestElement"
+      ],
+      "source": {
+        "filePath": "/src/cdk/testing/testbed/unit-test-element.ts",
+        "startLine": 68,
+        "endLine": 405
+      }
+    }
+  ],
+  "symbols": [
+    [
+      "ComponentFixture",
+      "@angular/core/testing"
+    ],
+    [
+      "flush",
+      "@angular/core/testing"
+    ],
+    [
+      "TestbedHarnessEnvironmentOptions",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironmentOptions",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironmentOptions.queryFn",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.constructor",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.forceStabilize",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.waitForTasksOutsideAngular",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.getDocumentRoot",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.createTestElement",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.createEnvironment",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.getAllRawElements",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.loader",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.documentRootLoader",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.getNativeElement",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "TestbedHarnessEnvironment.harnessForFixture",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.constructor",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.blur",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.clear",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.click",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.rightClick",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.focus",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.getCssValue",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.hover",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.mouseAway",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.sendKeys",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.text",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.setContenteditableValue",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.getAttribute",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.hasClass",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.getDimensions",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.getProperty",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.setInputValue",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.selectOptions",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.matchesSelector",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.isFocused",
+      "@angular/cdk/testing/testbed"
+    ],
+    [
+      "UnitTestElement.dispatchEvent",
+      "@angular/cdk/testing/testbed"
+    ]
+  ]
+}

node_modules/@angular/cdk/_index.scss

@@ -0,0 +1,8 @@
+@forward './overlay' show overlay, $overlay-container-z-index, $overlay-z-index,
+  $overlay-backdrop-z-index, $overlay-backdrop-color;
+@forward './a11y' show a11y-visually-hidden, high-contrast;
+@forward './text-field' show text-field-autosize, text-field-autofill,
+  text-field-autofill-color,
+  // `text-field` is deprecated, but we have to export it
+  // here in order for the theming API schematic to work.
+  text-field;

node_modules/@angular/cdk/a11y-module.d-DBHGyKoh.d.ts

@@ -0,0 +1,314 @@
+import * as i0 from '@angular/core';
+import { NgZone, Injector, OnDestroy, AfterContentInit, OnChanges, DoCheck, SimpleChanges, InjectionToken } from '@angular/core';
+import { ObserversModule } from './observers/index.js';
+import { C as CdkMonitorFocus } from './focus-monitor.d-CvvJeQRc.js';
+
+/**
+ * Configuration for the isFocusable method.
+ */
+declare class IsFocusableConfig {
+    /**
+     * Whether to count an element as focusable even if it is not currently visible.
+     */
+    ignoreVisibility: boolean;
+}
+/**
+ * Utility for checking the interactivity of an element, such as whether it is focusable or
+ * tabbable.
+ */
+declare class InteractivityChecker {
+    private _platform;
+    constructor(...args: unknown[]);
+    /**
+     * Gets whether an element is disabled.
+     *
+     * @param element Element to be checked.
+     * @returns Whether the element is disabled.
+     */
+    isDisabled(element: HTMLElement): boolean;
+    /**
+     * Gets whether an element is visible for the purposes of interactivity.
+     *
+     * This will capture states like `display: none` and `visibility: hidden`, but not things like
+     * being clipped by an `overflow: hidden` parent or being outside the viewport.
+     *
+     * @returns Whether the element is visible.
+     */
+    isVisible(element: HTMLElement): boolean;
+    /**
+     * Gets whether an element can be reached via Tab key.
+     * Assumes that the element has already been checked with isFocusable.
+     *
+     * @param element Element to be checked.
+     * @returns Whether the element is tabbable.
+     */
+    isTabbable(element: HTMLElement): boolean;
+    /**
+     * Gets whether an element can be focused by the user.
+     *
+     * @param element Element to be checked.
+     * @param config The config object with options to customize this method's behavior
+     * @returns Whether the element is focusable.
+     */
+    isFocusable(element: HTMLElement, config?: IsFocusableConfig): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InteractivityChecker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InteractivityChecker>;
+}
+
+/**
+ * Class that allows for trapping focus within a DOM element.
+ *
+ * This class currently uses a relatively simple approach to focus trapping.
+ * It assumes that the tab order is the same as DOM order, which is not necessarily true.
+ * Things like `tabIndex > 0`, flex `order`, and shadow roots can cause the two to be misaligned.
+ */
+declare class FocusTrap {
+    readonly _element: HTMLElement;
+    private _checker;
+    readonly _ngZone: NgZone;
+    readonly _document: Document;
+    /** @breaking-change 20.0.0 param to become required */
+    readonly _injector?: Injector | undefined;
+    private _startAnchor;
+    private _endAnchor;
+    private _hasAttached;
+    protected startAnchorListener: () => boolean;
+    protected endAnchorListener: () => boolean;
+    /** Whether the focus trap is active. */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    protected _enabled: boolean;
+    constructor(_element: HTMLElement, _checker: InteractivityChecker, _ngZone: NgZone, _document: Document, deferAnchors?: boolean, 
+    /** @breaking-change 20.0.0 param to become required */
+    _injector?: Injector | undefined);
+    /** Destroys the focus trap by cleaning up the anchors. */
+    destroy(): void;
+    /**
+     * Inserts the anchors into the DOM. This is usually done automatically
+     * in the constructor, but can be deferred for cases like directives with `*ngIf`.
+     * @returns Whether the focus trap managed to attach successfully. This may not be the case
+     * if the target element isn't currently in the DOM.
+     */
+    attachAnchors(): boolean;
+    /**
+     * Waits for the zone to stabilize, then focuses the first tabbable element.
+     * @returns Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfully.
+     */
+    focusInitialElementWhenReady(options?: FocusOptions): Promise<boolean>;
+    /**
+     * Waits for the zone to stabilize, then focuses
+     * the first tabbable element within the focus trap region.
+     * @returns Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfully.
+     */
+    focusFirstTabbableElementWhenReady(options?: FocusOptions): Promise<boolean>;
+    /**
+     * Waits for the zone to stabilize, then focuses
+     * the last tabbable element within the focus trap region.
+     * @returns Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfully.
+     */
+    focusLastTabbableElementWhenReady(options?: FocusOptions): Promise<boolean>;
+    /**
+     * Get the specified boundary element of the trapped region.
+     * @param bound The boundary to get (start or end of trapped region).
+     * @returns The boundary element.
+     */
+    private _getRegionBoundary;
+    /**
+     * Focuses the element that should be focused when the focus trap is initialized.
+     * @returns Whether focus was moved successfully.
+     */
+    focusInitialElement(options?: FocusOptions): boolean;
+    /**
+     * Focuses the first tabbable element within the focus trap region.
+     * @returns Whether focus was moved successfully.
+     */
+    focusFirstTabbableElement(options?: FocusOptions): boolean;
+    /**
+     * Focuses the last tabbable element within the focus trap region.
+     * @returns Whether focus was moved successfully.
+     */
+    focusLastTabbableElement(options?: FocusOptions): boolean;
+    /**
+     * Checks whether the focus trap has successfully been attached.
+     */
+    hasAttached(): boolean;
+    /** Get the first tabbable element from a DOM subtree (inclusive). */
+    private _getFirstTabbableElement;
+    /** Get the last tabbable element from a DOM subtree (inclusive). */
+    private _getLastTabbableElement;
+    /** Creates an anchor element. */
+    private _createAnchor;
+    /**
+     * Toggles the `tabindex` of an anchor, based on the enabled state of the focus trap.
+     * @param isEnabled Whether the focus trap is enabled.
+     * @param anchor Anchor on which to toggle the tabindex.
+     */
+    private _toggleAnchorTabIndex;
+    /**
+     * Toggles the`tabindex` of both anchors to either trap Tab focus or allow it to escape.
+     * @param enabled: Whether the anchors should trap Tab.
+     */
+    protected toggleAnchors(enabled: boolean): void;
+    /** Executes a function when the zone is stable. */
+    private _executeOnStable;
+}
+/**
+ * Factory that allows easy instantiation of focus traps.
+ */
+declare class FocusTrapFactory {
+    private _checker;
+    private _ngZone;
+    private _document;
+    private _injector;
+    constructor(...args: unknown[]);
+    /**
+     * Creates a focus-trapped region around the given element.
+     * @param element The element around which focus will be trapped.
+     * @param deferCaptureElements Defers the creation of focus-capturing elements to be done
+     *     manually by the user.
+     * @returns The created focus trap instance.
+     */
+    create(element: HTMLElement, deferCaptureElements?: boolean): FocusTrap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusTrapFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FocusTrapFactory>;
+}
+/** Directive for trapping focus within a region. */
+declare class CdkTrapFocus implements OnDestroy, AfterContentInit, OnChanges, DoCheck {
+    private _elementRef;
+    private _focusTrapFactory;
+    /** Underlying FocusTrap instance. */
+    focusTrap: FocusTrap;
+    /** Previously focused element to restore focus to upon destroy when using autoCapture. */
+    private _previouslyFocusedElement;
+    /** Whether the focus trap is active. */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Whether the directive should automatically move focus into the trapped region upon
+     * initialization and return focus to the previous activeElement upon destruction.
+     */
+    autoCapture: boolean;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    ngDoCheck(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _captureFocus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTrapFocus, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTrapFocus, "[cdkTrapFocus]", ["cdkTrapFocus"], { "enabled": { "alias": "cdkTrapFocus"; "required": false; }; "autoCapture": { "alias": "cdkTrapFocusAutoCapture"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_enabled: unknown;
+    static ngAcceptInputType_autoCapture: unknown;
+}
+
+/** Possible politeness levels. */
+type AriaLivePoliteness = 'off' | 'polite' | 'assertive';
+declare const LIVE_ANNOUNCER_ELEMENT_TOKEN: InjectionToken<HTMLElement | null>;
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare function LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY(): null;
+/** Object that can be used to configure the default options for the LiveAnnouncer. */
+interface LiveAnnouncerDefaultOptions {
+    /** Default politeness for the announcements. */
+    politeness?: AriaLivePoliteness;
+    /** Default duration for the announcement messages. */
+    duration?: number;
+}
+/** Injection token that can be used to configure the default options for the LiveAnnouncer. */
+declare const LIVE_ANNOUNCER_DEFAULT_OPTIONS: InjectionToken<LiveAnnouncerDefaultOptions>;
+
+declare class LiveAnnouncer implements OnDestroy {
+    private _ngZone;
+    private _defaultOptions;
+    private _liveElement;
+    private _document;
+    private _previousTimeout;
+    private _currentPromise;
+    private _currentResolve;
+    constructor(...args: unknown[]);
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string): Promise<void>;
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @param politeness The politeness of the announcer element.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string, politeness?: AriaLivePoliteness): Promise<void>;
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @param duration Time in milliseconds after which to clear out the announcer element. Note
+     *   that this takes effect after the message has been added to the DOM, which can be up to
+     *   100ms after `announce` has been called.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string, duration?: number): Promise<void>;
+    /**
+     * Announces a message to screen readers.
+     * @param message Message to be announced to the screen reader.
+     * @param politeness The politeness of the announcer element.
+     * @param duration Time in milliseconds after which to clear out the announcer element. Note
+     *   that this takes effect after the message has been added to the DOM, which can be up to
+     *   100ms after `announce` has been called.
+     * @returns Promise that will be resolved when the message is added to the DOM.
+     */
+    announce(message: string, politeness?: AriaLivePoliteness, duration?: number): Promise<void>;
+    /**
+     * Clears the current text from the announcer element. Can be used to prevent
+     * screen readers from reading the text out again while the user is going
+     * through the page landmarks.
+     */
+    clear(): void;
+    ngOnDestroy(): void;
+    private _createLiveElement;
+    /**
+     * Some browsers won't expose the accessibility node of the live announcer element if there is an
+     * `aria-modal` and the live announcer is outside of it. This method works around the issue by
+     * pointing the `aria-owns` of all modals to the live announcer element.
+     */
+    private _exposeAnnouncerToModals;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LiveAnnouncer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LiveAnnouncer>;
+}
+/**
+ * A directive that works similarly to aria-live, but uses the LiveAnnouncer to ensure compatibility
+ * with a wider range of browsers and screen readers.
+ */
+declare class CdkAriaLive implements OnDestroy {
+    private _elementRef;
+    private _liveAnnouncer;
+    private _contentObserver;
+    private _ngZone;
+    /** The aria-live politeness level to use when announcing messages. */
+    get politeness(): AriaLivePoliteness;
+    set politeness(value: AriaLivePoliteness);
+    private _politeness;
+    /** Time in milliseconds after which to clear out the announcer element. */
+    duration: number;
+    private _previousAnnouncedText?;
+    private _subscription;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkAriaLive, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkAriaLive, "[cdkAriaLive]", ["cdkAriaLive"], { "politeness": { "alias": "cdkAriaLive"; "required": false; }; "duration": { "alias": "cdkAriaLiveDuration"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class A11yModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<A11yModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<A11yModule, never, [typeof ObserversModule, typeof CdkAriaLive, typeof CdkTrapFocus, typeof CdkMonitorFocus], [typeof CdkAriaLive, typeof CdkTrapFocus, typeof CdkMonitorFocus]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<A11yModule>;
+}
+
+export { A11yModule as A, CdkTrapFocus as C, FocusTrapFactory as F, InteractivityChecker as I, LiveAnnouncer as L, FocusTrap as a, IsFocusableConfig as b, CdkAriaLive as c, LIVE_ANNOUNCER_ELEMENT_TOKEN as e, LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY as f, LIVE_ANNOUNCER_DEFAULT_OPTIONS as h };
+export type { AriaLivePoliteness as d, LiveAnnouncerDefaultOptions as g };

node_modules/@angular/cdk/a11y-prebuilt.css

@@ -0,0 +1 @@
+.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;white-space:nowrap;outline:0;-webkit-appearance:none;-moz-appearance:none;left:0}[dir=rtl] .cdk-visually-hidden{left:auto;right:0}

node_modules/@angular/cdk/a11y/_index.scss

@@ -0,0 +1,60 @@
+/// Emits a CSS class, `.cdk-visually-hidden`. This class can be applied to an element
+/// to make that element visually hidden while remaining available to assistive technology.
+@mixin a11y-visually-hidden() {
+  .cdk-visually-hidden {
+    border: 0;
+    clip: rect(0 0 0 0);
+    height: 1px;
+    margin: -1px;
+    overflow: hidden;
+    padding: 0;
+    position: absolute;
+    width: 1px;
+
+    // This works around a Chrome bug that can cause the tab to crash when large amounts of
+    // non-English text get wrapped: https://bugs.chromium.org/p/chromium/issues/detail?id=1201444
+    white-space: nowrap;
+
+    // Avoid browsers rendering the focus ring in some cases.
+    outline: 0;
+
+    // Avoid some cases where the browser will still render the native controls (see #9049).
+    -webkit-appearance: none;
+    -moz-appearance: none;
+
+    // We need at least one of top/bottom/left/right in order to prevent cases where the
+    // absolute-positioned element is pushed down and can affect scrolling (see #24597).
+    // `left` was chosen here, because it's the least likely to break overrides where the
+    // element might have been positioned (e.g. `mat-checkbox`).
+    left: 0;
+
+    [dir='rtl'] & {
+      left: auto;
+      right: 0;
+    }
+  }
+}
+
+/// @deprecated Use `a11y-visually-hidden`.
+@mixin a11y() {
+  @include a11y-visually-hidden;
+}
+
+/// Applies styles for users in high contrast mode.
+///
+/// @param {String} target Type of high contrast setting to target. Can be `active` or `none`.
+///   Defaults to `active`.
+/// @param {String} encapsulation No longer used and will be removed.
+@mixin high-contrast($target: active, $encapsulation: null) {
+  // Historically we used to support `black-on-white` and `white-on-black` so we
+  // allow them here anyway. They'll be coerced to `active` below.
+  @if ($target != 'active' and $target != 'none' and $target != 'black-on-white' and
+    $target != 'white-on-black') {
+    @error 'Unknown cdk-high-contrast value "#{$target}" provided. ' +
+           'Allowed values are "active" and "none"';
+  }
+
+  @media (forced-colors: #{if($target == none, none, active)}) {
+    @content;
+  }
+}

node_modules/@angular/cdk/a11y/index.d.ts

@@ -0,0 +1,550 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, Provider, QueryList, InjectionToken, NgZone, Injector } from '@angular/core';
+export { A as ActiveDescendantKeyManager, H as Highlightable } from '../activedescendant-key-manager.d-Bjic5obv.js';
+export { a as FocusKeyManager, F as FocusableOption } from '../focus-key-manager.d-BIKDy8oD.js';
+export { a as ListKeyManager, b as ListKeyManagerModifierKey, L as ListKeyManagerOption } from '../list-key-manager.d-BlK3jyRn.js';
+import { Subject, Observable } from 'rxjs';
+import { a as TreeKeyManagerItem, T as TreeKeyManagerStrategy, b as TreeKeyManagerFactory, c as TreeKeyManagerOptions } from '../tree-key-manager-strategy.d-XB6M79l-.js';
+import { a as FocusTrap, I as InteractivityChecker } from '../a11y-module.d-DBHGyKoh.js';
+export { A as A11yModule, d as AriaLivePoliteness, c as CdkAriaLive, C as CdkTrapFocus, F as FocusTrapFactory, b as IsFocusableConfig, h as LIVE_ANNOUNCER_DEFAULT_OPTIONS, e as LIVE_ANNOUNCER_ELEMENT_TOKEN, f as LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY, L as LiveAnnouncer, g as LiveAnnouncerDefaultOptions } from '../a11y-module.d-DBHGyKoh.js';
+export { C as CdkMonitorFocus, d as FOCUS_MONITOR_DEFAULT_OPTIONS, e as FocusMonitor, b as FocusMonitorDetectionMode, c as FocusMonitorOptions, a as FocusOptions, F as FocusOrigin } from '../focus-monitor.d-CvvJeQRc.js';
+import '../observers/index.js';
+import '../number-property.d-CJVxXUcb.js';
+
+/**
+ * Interface used to register message elements and keep a count of how many registrations have
+ * the same message and the reference to the message element used for the `aria-describedby`.
+ */
+interface RegisteredMessage {
+    /** The element containing the message. */
+    messageElement: Element;
+    /** The number of elements that reference this message element via `aria-describedby`. */
+    referenceCount: number;
+}
+/**
+ * ID used for the body container where all messages are appended.
+ * @deprecated No longer being used. To be removed.
+ * @breaking-change 14.0.0
+ */
+declare const MESSAGES_CONTAINER_ID = "cdk-describedby-message-container";
+/**
+ * ID prefix used for each created message element.
+ * @deprecated To be turned into a private variable.
+ * @breaking-change 14.0.0
+ */
+declare const CDK_DESCRIBEDBY_ID_PREFIX = "cdk-describedby-message";
+/**
+ * Attribute given to each host element that is described by a message element.
+ * @deprecated To be turned into a private variable.
+ * @breaking-change 14.0.0
+ */
+declare const CDK_DESCRIBEDBY_HOST_ATTRIBUTE = "cdk-describedby-host";
+/**
+ * Utility that creates visually hidden elements with a message content. Useful for elements that
+ * want to use aria-describedby to further describe themselves without adding additional visual
+ * content.
+ */
+declare class AriaDescriber implements OnDestroy {
+    private _platform;
+    private _document;
+    /** Map of all registered message elements that have been placed into the document. */
+    private _messageRegistry;
+    /** Container for all registered messages. */
+    private _messagesContainer;
+    /** Unique ID for the service. */
+    private readonly _id;
+    constructor(...args: unknown[]);
+    /**
+     * Adds to the host element an aria-describedby reference to a hidden element that contains
+     * the message. If the same message has already been registered, then it will reuse the created
+     * message element.
+     */
+    describe(hostElement: Element, message: string, role?: string): void;
+    /**
+     * Adds to the host element an aria-describedby reference to an already-existing message element.
+     */
+    describe(hostElement: Element, message: HTMLElement): void;
+    /** Removes the host element's aria-describedby reference to the message. */
+    removeDescription(hostElement: Element, message: string, role?: string): void;
+    /** Removes the host element's aria-describedby reference to the message element. */
+    removeDescription(hostElement: Element, message: HTMLElement): void;
+    /** Unregisters all created message elements and removes the message container. */
+    ngOnDestroy(): void;
+    /**
+     * Creates a new element in the visually hidden message container element with the message
+     * as its content and adds it to the message registry.
+     */
+    private _createMessageElement;
+    /** Deletes the message element from the global messages container. */
+    private _deleteMessageElement;
+    /** Creates the global container for all aria-describedby messages. */
+    private _createMessagesContainer;
+    /** Removes all cdk-describedby messages that are hosted through the element. */
+    private _removeCdkDescribedByReferenceIds;
+    /**
+     * Adds a message reference to the element using aria-describedby and increments the registered
+     * message's reference count.
+     */
+    private _addMessageReference;
+    /**
+     * Removes a message reference from the element using aria-describedby
+     * and decrements the registered message's reference count.
+     */
+    private _removeMessageReference;
+    /** Returns true if the element has been described by the provided message ID. */
+    private _isElementDescribedByMessage;
+    /** Determines whether a message can be described on a particular element. */
+    private _canBeDescribed;
+    /** Checks whether a node is an Element node. */
+    private _isElementNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AriaDescriber, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AriaDescriber>;
+}
+
+/**
+ * Adds the given ID to the specified ARIA attribute on an element.
+ * Used for attributes such as aria-labelledby, aria-owns, etc.
+ */
+declare function addAriaReferencedId(el: Element, attr: `aria-${string}`, id: string): void;
+/**
+ * Removes the given ID from the specified ARIA attribute on an element.
+ * Used for attributes such as aria-labelledby, aria-owns, etc.
+ */
+declare function removeAriaReferencedId(el: Element, attr: `aria-${string}`, id: string): void;
+/**
+ * Gets the list of IDs referenced by the given ARIA attribute on an element.
+ * Used for attributes such as aria-labelledby, aria-owns, etc.
+ */
+declare function getAriaReferenceIds(el: Element, attr: string): string[];
+
+/**
+ * @docs-private
+ *
+ * Opt-out of Tree of key manager behavior.
+ *
+ * When provided, Tree has same focus management behavior as before TreeKeyManager was introduced.
+ *  - Tree does not respond to keyboard interaction
+ *  - Tree node allows tabindex to be set by Input binding
+ *  - Tree node allows tabindex to be set by attribute binding
+ *
+ * @deprecated NoopTreeKeyManager deprecated. Use TreeKeyManager or inject a
+ * TreeKeyManagerStrategy instead. To be removed in a future version.
+ *
+ * @breaking-change 21.0.0
+ */
+declare class NoopTreeKeyManager<T extends TreeKeyManagerItem> implements TreeKeyManagerStrategy<T> {
+    readonly _isNoopTreeKeyManager = true;
+    readonly change: Subject<T | null>;
+    destroy(): void;
+    onKeydown(): void;
+    getActiveItemIndex(): null;
+    getActiveItem(): null;
+    focusItem(): void;
+}
+/**
+ * @docs-private
+ *
+ * Opt-out of Tree of key manager behavior.
+ *
+ * When provided, Tree has same focus management behavior as before TreeKeyManager was introduced.
+ *  - Tree does not respond to keyboard interaction
+ *  - Tree node allows tabindex to be set by Input binding
+ *  - Tree node allows tabindex to be set by attribute binding
+ *
+ * @deprecated NoopTreeKeyManager deprecated. Use TreeKeyManager or inject a
+ * TreeKeyManagerStrategy instead. To be removed in a future version.
+ *
+ * @breaking-change 21.0.0
+ */
+declare function NOOP_TREE_KEY_MANAGER_FACTORY<T extends TreeKeyManagerItem>(): TreeKeyManagerFactory<T>;
+/**
+ * @docs-private
+ *
+ * Opt-out of Tree of key manager behavior.
+ *
+ * When provided, Tree has same focus management behavior as before TreeKeyManager was introduced.
+ *  - Tree does not respond to keyboard interaction
+ *  - Tree node allows tabindex to be set by Input binding
+ *  - Tree node allows tabindex to be set by attribute binding
+ *
+ * @deprecated NoopTreeKeyManager deprecated. Use TreeKeyManager or inject a
+ * TreeKeyManagerStrategy instead. To be removed in a future version.
+ *
+ * @breaking-change 21.0.0
+ */
+declare const NOOP_TREE_KEY_MANAGER_FACTORY_PROVIDER: Provider;
+
+/**
+ * This class manages keyboard events for trees. If you pass it a QueryList or other list of tree
+ * items, it will set the active item, focus, handle expansion and typeahead correctly when
+ * keyboard events occur.
+ */
+declare class TreeKeyManager<T extends TreeKeyManagerItem> implements TreeKeyManagerStrategy<T> {
+    /** The index of the currently active (focused) item. */
+    private _activeItemIndex;
+    /** The currently active (focused) item. */
+    private _activeItem;
+    /** Whether or not we activate the item when it's focused. */
+    private _shouldActivationFollowFocus;
+    /**
+     * The orientation that the tree is laid out in. In `rtl` mode, the behavior of Left and
+     * Right arrow are switched.
+     */
+    private _horizontalOrientation;
+    /**
+     * Predicate function that can be used to check whether an item should be skipped
+     * by the key manager.
+     *
+     * The default value for this doesn't skip any elements in order to keep tree items focusable
+     * when disabled. This aligns with ARIA guidelines:
+     * https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/#focusabilityofdisabledcontrols.
+     */
+    private _skipPredicateFn;
+    /** Function to determine equivalent items. */
+    private _trackByFn;
+    /** Synchronous cache of the items to manage. */
+    private _items;
+    private _typeahead?;
+    private _typeaheadSubscription;
+    private _hasInitialFocused;
+    private _initializeFocus;
+    /**
+     *
+     * @param items List of TreeKeyManager options. Can be synchronous or asynchronous.
+     * @param config Optional configuration options. By default, use 'ltr' horizontal orientation. By
+     * default, do not skip any nodes. By default, key manager only calls `focus` method when items
+     * are focused and does not call `activate`. If `typeaheadDefaultInterval` is `true`, use a
+     * default interval of 200ms.
+     */
+    constructor(items: Observable<T[]> | QueryList<T> | T[], config: TreeKeyManagerOptions<T>);
+    /** Stream that emits any time the focused item changes. */
+    readonly change: Subject<T | null>;
+    /** Cleans up the key manager. */
+    destroy(): void;
+    /**
+     * Handles a keyboard event on the tree.
+     * @param event Keyboard event that represents the user interaction with the tree.
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /** Index of the currently active item. */
+    getActiveItemIndex(): number | null;
+    /** The currently active item. */
+    getActiveItem(): T | null;
+    /** Focus the first available item. */
+    private _focusFirstItem;
+    /** Focus the last available item. */
+    private _focusLastItem;
+    /** Focus the next available item. */
+    private _focusNextItem;
+    /** Focus the previous available item. */
+    private _focusPreviousItem;
+    /**
+     * Focus the provided item by index.
+     * @param index The index of the item to focus.
+     * @param options Additional focusing options.
+     */
+    focusItem(index: number, options?: {
+        emitChangeEvent?: boolean;
+    }): void;
+    focusItem(item: T, options?: {
+        emitChangeEvent?: boolean;
+    }): void;
+    focusItem(itemOrIndex: number | T, options?: {
+        emitChangeEvent?: boolean;
+    }): void;
+    private _updateActiveItemIndex;
+    private _setTypeAhead;
+    private _findNextAvailableItemIndex;
+    private _findPreviousAvailableItemIndex;
+    /**
+     * If the item is already expanded, we collapse the item. Otherwise, we will focus the parent.
+     */
+    private _collapseCurrentItem;
+    /**
+     * If the item is already collapsed, we expand the item. Otherwise, we will focus the first child.
+     */
+    private _expandCurrentItem;
+    private _isCurrentItemExpanded;
+    private _isItemDisabled;
+    /** For all items that are the same level as the current item, we expand those items. */
+    private _expandAllItemsAtCurrentItemLevel;
+    private _activateCurrentItem;
+}
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare function TREE_KEY_MANAGER_FACTORY<T extends TreeKeyManagerItem>(): TreeKeyManagerFactory<T>;
+/** Injection token that determines the key manager to use. */
+declare const TREE_KEY_MANAGER: InjectionToken<TreeKeyManagerFactory<any>>;
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare const TREE_KEY_MANAGER_FACTORY_PROVIDER: {
+    provide: InjectionToken<TreeKeyManagerFactory<any>>;
+    useFactory: typeof TREE_KEY_MANAGER_FACTORY;
+};
+
+/**
+ * Options for creating a ConfigurableFocusTrap.
+ */
+interface ConfigurableFocusTrapConfig {
+    /**
+     * Whether to defer the creation of FocusTrap elements to be done manually by the user.
+     */
+    defer: boolean;
+}
+
+/** The injection token used to specify the inert strategy. */
+declare const FOCUS_TRAP_INERT_STRATEGY: InjectionToken<FocusTrapInertStrategy>;
+/**
+ * A strategy that dictates how FocusTrap should prevent elements
+ * outside of the FocusTrap from being focused.
+ */
+interface FocusTrapInertStrategy {
+    /** Makes all elements outside focusTrap unfocusable. */
+    preventFocus(focusTrap: FocusTrap): void;
+    /** Reverts elements made unfocusable by preventFocus to their previous state. */
+    allowFocus(focusTrap: FocusTrap): void;
+}
+
+/**
+ * A FocusTrap managed by FocusTrapManager.
+ * Implemented by ConfigurableFocusTrap to avoid circular dependency.
+ */
+interface ManagedFocusTrap {
+    _enable(): void;
+    _disable(): void;
+    focusInitialElementWhenReady(): Promise<boolean>;
+}
+/** Injectable that ensures only the most recently enabled FocusTrap is active. */
+declare class FocusTrapManager {
+    private _focusTrapStack;
+    /**
+     * Disables the FocusTrap at the top of the stack, and then pushes
+     * the new FocusTrap onto the stack.
+     */
+    register(focusTrap: ManagedFocusTrap): void;
+    /**
+     * Removes the FocusTrap from the stack, and activates the
+     * FocusTrap that is the new top of the stack.
+     */
+    deregister(focusTrap: ManagedFocusTrap): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusTrapManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FocusTrapManager>;
+}
+
+/**
+ * Class that allows for trapping focus within a DOM element.
+ *
+ * This class uses a strategy pattern that determines how it traps focus.
+ * See FocusTrapInertStrategy.
+ */
+declare class ConfigurableFocusTrap extends FocusTrap implements ManagedFocusTrap {
+    private _focusTrapManager;
+    private _inertStrategy;
+    /** Whether the FocusTrap is enabled. */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    constructor(_element: HTMLElement, _checker: InteractivityChecker, _ngZone: NgZone, _document: Document, _focusTrapManager: FocusTrapManager, _inertStrategy: FocusTrapInertStrategy, config: ConfigurableFocusTrapConfig, injector?: Injector);
+    /** Notifies the FocusTrapManager that this FocusTrap will be destroyed. */
+    destroy(): void;
+    /** @docs-private Implemented as part of ManagedFocusTrap. */
+    _enable(): void;
+    /** @docs-private Implemented as part of ManagedFocusTrap. */
+    _disable(): void;
+}
+
+/** Factory that allows easy instantiation of configurable focus traps. */
+declare class ConfigurableFocusTrapFactory {
+    private _checker;
+    private _ngZone;
+    private _focusTrapManager;
+    private _document;
+    private _inertStrategy;
+    private readonly _injector;
+    constructor(...args: unknown[]);
+    /**
+     * Creates a focus-trapped region around the given element.
+     * @param element The element around which focus will be trapped.
+     * @param config The focus trap configuration.
+     * @returns The created focus trap instance.
+     */
+    create(element: HTMLElement, config?: ConfigurableFocusTrapConfig): ConfigurableFocusTrap;
+    /**
+     * @deprecated Pass a config object instead of the `deferCaptureElements` flag.
+     * @breaking-change 11.0.0
+     */
+    create(element: HTMLElement, deferCaptureElements: boolean): ConfigurableFocusTrap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurableFocusTrapFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurableFocusTrapFactory>;
+}
+
+/**
+ * Lightweight FocusTrapInertStrategy that adds a document focus event
+ * listener to redirect focus back inside the FocusTrap.
+ */
+declare class EventListenerFocusTrapInertStrategy implements FocusTrapInertStrategy {
+    /** Focus event handler. */
+    private _listener;
+    /** Adds a document event listener that keeps focus inside the FocusTrap. */
+    preventFocus(focusTrap: ConfigurableFocusTrap): void;
+    /** Removes the event listener added in preventFocus. */
+    allowFocus(focusTrap: ConfigurableFocusTrap): void;
+    /**
+     * Refocuses the first element in the FocusTrap if the focus event target was outside
+     * the FocusTrap.
+     *
+     * This is an event listener callback. The event listener is added in runOutsideAngular,
+     * so all this code runs outside Angular as well.
+     */
+    private _trapFocus;
+}
+
+/**
+ * The input modalities detected by this service. Null is used if the input modality is unknown.
+ */
+type InputModality = 'keyboard' | 'mouse' | 'touch' | null;
+/** Options to configure the behavior of the InputModalityDetector. */
+interface InputModalityDetectorOptions {
+    /** Keys to ignore when detecting keyboard input modality. */
+    ignoreKeys?: number[];
+}
+/**
+ * Injectable options for the InputModalityDetector. These are shallowly merged with the default
+ * options.
+ */
+declare const INPUT_MODALITY_DETECTOR_OPTIONS: InjectionToken<InputModalityDetectorOptions>;
+/**
+ * Default options for the InputModalityDetector.
+ *
+ * Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect
+ * keyboard input modality) for two reasons:
+ *
+ * 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open
+ *    in new tab', and are thus less representative of actual keyboard interaction.
+ * 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but
+ *    confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore
+ *    these keys so as to not update the input modality.
+ *
+ * Note that we do not by default ignore the right Meta key on Safari because it has the same key
+ * code as the ContextMenu key on other browsers. When we switch to using event.key, we can
+ * distinguish between the two.
+ */
+declare const INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS: InputModalityDetectorOptions;
+/**
+ * Service that detects the user's input modality.
+ *
+ * This service does not update the input modality when a user navigates with a screen reader
+ * (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC
+ * cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not
+ * fire as expected in these modes) but is also arguably the correct behavior. Navigating with a
+ * screen reader is akin to visually scanning a page, and should not be interpreted as actual user
+ * input interaction.
+ *
+ * When a user is not navigating but *interacting* with a screen reader, this service attempts to
+ * update the input modality to keyboard, but in general this service's behavior is largely
+ * undefined.
+ */
+declare class InputModalityDetector implements OnDestroy {
+    private readonly _platform;
+    private readonly _listenerCleanups;
+    /** Emits whenever an input modality is detected. */
+    readonly modalityDetected: Observable<InputModality>;
+    /** Emits when the input modality changes. */
+    readonly modalityChanged: Observable<InputModality>;
+    /** The most recently detected input modality. */
+    get mostRecentModality(): InputModality;
+    /**
+     * The most recently detected input modality event target. Is null if no input modality has been
+     * detected or if the associated event target is null for some unknown reason.
+     */
+    _mostRecentTarget: HTMLElement | null;
+    /** The underlying BehaviorSubject that emits whenever an input modality is detected. */
+    private readonly _modality;
+    /** Options for this InputModalityDetector. */
+    private readonly _options;
+    /**
+     * The timestamp of the last touch input modality. Used to determine whether mousedown events
+     * should be attributed to mouse or touch.
+     */
+    private _lastTouchMs;
+    /**
+     * Handles keydown events. Must be an arrow function in order to preserve the context when it gets
+     * bound.
+     */
+    private _onKeydown;
+    /**
+     * Handles mousedown events. Must be an arrow function in order to preserve the context when it
+     * gets bound.
+     */
+    private _onMousedown;
+    /**
+     * Handles touchstart events. Must be an arrow function in order to preserve the context when it
+     * gets bound.
+     */
+    private _onTouchstart;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputModalityDetector, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InputModalityDetector>;
+}
+
+/** Gets whether an event could be a faked `mousedown` event dispatched by a screen reader. */
+declare function isFakeMousedownFromScreenReader(event: MouseEvent): boolean;
+/** Gets whether an event could be a faked `touchstart` event dispatched by a screen reader. */
+declare function isFakeTouchstartFromScreenReader(event: TouchEvent): boolean;
+
+/** Set of possible high-contrast mode backgrounds. */
+declare enum HighContrastMode {
+    NONE = 0,
+    BLACK_ON_WHITE = 1,
+    WHITE_ON_BLACK = 2
+}
+/**
+ * Service to determine whether the browser is currently in a high-contrast-mode environment.
+ *
+ * Microsoft Windows supports an accessibility feature called "High Contrast Mode". This mode
+ * changes the appearance of all applications, including web applications, to dramatically increase
+ * contrast.
+ *
+ * IE, Edge, and Firefox currently support this mode. Chrome does not support Windows High Contrast
+ * Mode. This service does not detect high-contrast mode as added by the Chrome "High Contrast"
+ * browser extension.
+ */
+declare class HighContrastModeDetector implements OnDestroy {
+    private _platform;
+    /**
+     * Figuring out the high contrast mode and adding the body classes can cause
+     * some expensive layouts. This flag is used to ensure that we only do it once.
+     */
+    private _hasCheckedHighContrastMode;
+    private _document;
+    private _breakpointSubscription;
+    constructor(...args: unknown[]);
+    /** Gets the current high-contrast-mode for the page. */
+    getHighContrastMode(): HighContrastMode;
+    ngOnDestroy(): void;
+    /** Applies CSS classes indicating high-contrast mode to document body (browser-only). */
+    _applyBodyHighContrastModeCssClasses(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighContrastModeDetector, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HighContrastModeDetector>;
+}
+
+/** Service that generates unique IDs for DOM nodes. */
+declare class _IdGenerator {
+    private _appId;
+    /**
+     * Generates a unique ID with a specific prefix.
+     * @param prefix Prefix to add to the ID.
+     */
+    getId(prefix: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_IdGenerator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<_IdGenerator>;
+}
+
+export { AriaDescriber, CDK_DESCRIBEDBY_HOST_ATTRIBUTE, CDK_DESCRIBEDBY_ID_PREFIX, ConfigurableFocusTrap, ConfigurableFocusTrapFactory, EventListenerFocusTrapInertStrategy, FOCUS_TRAP_INERT_STRATEGY, FocusTrap, HighContrastMode, HighContrastModeDetector, INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS, INPUT_MODALITY_DETECTOR_OPTIONS, InputModalityDetector, InteractivityChecker, MESSAGES_CONTAINER_ID, NOOP_TREE_KEY_MANAGER_FACTORY, NOOP_TREE_KEY_MANAGER_FACTORY_PROVIDER, NoopTreeKeyManager, TREE_KEY_MANAGER, TREE_KEY_MANAGER_FACTORY, TREE_KEY_MANAGER_FACTORY_PROVIDER, TreeKeyManager, TreeKeyManagerFactory, TreeKeyManagerItem, TreeKeyManagerOptions, TreeKeyManagerStrategy, _IdGenerator, addAriaReferencedId, getAriaReferenceIds, isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader, removeAriaReferencedId };
+export type { ConfigurableFocusTrapConfig, FocusTrapInertStrategy, InputModality, InputModalityDetectorOptions, RegisteredMessage };

node_modules/@angular/cdk/accordion/index.d.ts

@@ -0,0 +1,90 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, OnChanges, SimpleChanges, OnInit, EventEmitter } from '@angular/core';
+import { U as UniqueSelectionDispatcher } from '../unique-selection-dispatcher.d-DSFqf1MM.js';
+import { Subject } from 'rxjs';
+
+/**
+ * Injection token that can be used to reference instances of `CdkAccordion`. It serves
+ * as alternative token to the actual `CdkAccordion` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CDK_ACCORDION: InjectionToken<CdkAccordion>;
+/**
+ * Directive whose purpose is to manage the expanded state of CdkAccordionItem children.
+ */
+declare class CdkAccordion implements OnDestroy, OnChanges {
+    /** Emits when the state of the accordion changes */
+    readonly _stateChanges: Subject<SimpleChanges>;
+    /** Stream that emits true/false when openAll/closeAll is triggered. */
+    readonly _openCloseAllActions: Subject<boolean>;
+    /** A readonly id value to use for unique selection coordination. */
+    readonly id: string;
+    /** Whether the accordion should allow multiple expanded accordion items simultaneously. */
+    multi: boolean;
+    /** Opens all enabled accordion items in an accordion where multi is enabled. */
+    openAll(): void;
+    /** Closes all enabled accordion items. */
+    closeAll(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkAccordion, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkAccordion, "cdk-accordion, [cdkAccordion]", ["cdkAccordion"], { "multi": { "alias": "multi"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_multi: unknown;
+}
+
+/**
+ * A basic directive expected to be extended and decorated as a component.  Sets up all
+ * events and attributes needed to be managed by a CdkAccordion parent.
+ */
+declare class CdkAccordionItem implements OnInit, OnDestroy {
+    accordion: CdkAccordion;
+    private _changeDetectorRef;
+    protected _expansionDispatcher: UniqueSelectionDispatcher;
+    /** Subscription to openAll/closeAll events. */
+    private _openCloseAllSubscription;
+    /** Event emitted every time the AccordionItem is closed. */
+    readonly closed: EventEmitter<void>;
+    /** Event emitted every time the AccordionItem is opened. */
+    readonly opened: EventEmitter<void>;
+    /** Event emitted when the AccordionItem is destroyed. */
+    readonly destroyed: EventEmitter<void>;
+    /**
+     * Emits whenever the expanded state of the accordion changes.
+     * Primarily used to facilitate two-way binding.
+     * @docs-private
+     */
+    readonly expandedChange: EventEmitter<boolean>;
+    /** The unique AccordionItem id. */
+    readonly id: string;
+    /** Whether the AccordionItem is expanded. */
+    get expanded(): boolean;
+    set expanded(expanded: boolean);
+    private _expanded;
+    /** Whether the AccordionItem is disabled. */
+    disabled: boolean;
+    /** Unregister function for _expansionDispatcher. */
+    private _removeUniqueSelectionListener;
+    constructor(...args: unknown[]);
+    ngOnInit(): void;
+    /** Emits an event for the accordion item being destroyed. */
+    ngOnDestroy(): void;
+    /** Toggles the expanded state of the accordion item. */
+    toggle(): void;
+    /** Sets the expanded state of the accordion item to false. */
+    close(): void;
+    /** Sets the expanded state of the accordion item to true. */
+    open(): void;
+    private _subscribeToOpenCloseAllActions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkAccordionItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkAccordionItem, "cdk-accordion-item, [cdkAccordionItem]", ["cdkAccordionItem"], { "expanded": { "alias": "expanded"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "closed": "closed"; "opened": "opened"; "destroyed": "destroyed"; "expandedChange": "expandedChange"; }, never, never, true, never>;
+    static ngAcceptInputType_expanded: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class CdkAccordionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkAccordionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkAccordionModule, never, [typeof CdkAccordion, typeof CdkAccordionItem], [typeof CdkAccordion, typeof CdkAccordionItem]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CdkAccordionModule>;
+}
+
+export { CDK_ACCORDION, CdkAccordion, CdkAccordionItem, CdkAccordionModule };

node_modules/@angular/cdk/activedescendant-key-manager.d-Bjic5obv.d.ts

@@ -0,0 +1,32 @@
+import { L as ListKeyManagerOption, a as ListKeyManager } from './list-key-manager.d-BlK3jyRn.js';
+
+/**
+ * This is the interface for highlightable items (used by the ActiveDescendantKeyManager).
+ * Each item must know how to style itself as active or inactive and whether or not it is
+ * currently disabled.
+ */
+interface Highlightable extends ListKeyManagerOption {
+    /** Applies the styles for an active item to this item. */
+    setActiveStyles(): void;
+    /** Applies the styles for an inactive item to this item. */
+    setInactiveStyles(): void;
+}
+declare class ActiveDescendantKeyManager<T> extends ListKeyManager<Highlightable & T> {
+    /**
+     * Sets the active item to the item at the specified index and adds the
+     * active styles to the newly active item. Also removes active styles
+     * from the previously active item.
+     * @param index Index of the item to be set as active.
+     */
+    setActiveItem(index: number): void;
+    /**
+     * Sets the active item to the item to the specified one and adds the
+     * active styles to the it. Also removes active styles from the
+     * previously active item.
+     * @param item Item to be set as active.
+     */
+    setActiveItem(item: T): void;
+}
+
+export { ActiveDescendantKeyManager as A };
+export type { Highlightable as H };

node_modules/@angular/cdk/bidi-module.d-D-fEBKdS.d.ts

@@ -0,0 +1,54 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, EventEmitter, AfterContentInit } from '@angular/core';
+
+type Direction = 'ltr' | 'rtl';
+/**
+ * The directionality (LTR / RTL) context for the application (or a subtree of it).
+ * Exposes the current direction and a stream of direction changes.
+ */
+declare class Directionality implements OnDestroy {
+    /** The current 'ltr' or 'rtl' value. */
+    readonly value: Direction;
+    /** Stream that emits whenever the 'ltr' / 'rtl' state changes. */
+    readonly change: EventEmitter<Direction>;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Directionality, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Directionality>;
+}
+
+/**
+ * Directive to listen for changes of direction of part of the DOM.
+ *
+ * Provides itself as Directionality such that descendant directives only need to ever inject
+ * Directionality to get the closest direction.
+ */
+declare class Dir implements Directionality, AfterContentInit, OnDestroy {
+    /** Normalized direction that accounts for invalid/unsupported values. */
+    private _dir;
+    /** Whether the `value` has been set to its initial value. */
+    private _isInitialized;
+    /** Direction as passed in by the consumer. */
+    _rawDir: string;
+    /** Event emitted when the direction changes. */
+    readonly change: EventEmitter<Direction>;
+    /** @docs-private */
+    get dir(): Direction;
+    set dir(value: Direction | 'auto');
+    /** Current layout direction of the element. */
+    get value(): Direction;
+    /** Initialize once default value has been set. */
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Dir, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Dir, "[dir]", ["dir"], { "dir": { "alias": "dir"; "required": false; }; }, { "change": "dirChange"; }, never, never, true, never>;
+}
+
+declare class BidiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BidiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BidiModule, never, [typeof Dir], [typeof Dir]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BidiModule>;
+}
+
+export { BidiModule as B, Directionality as D, Dir as b };
+export type { Direction as a };

node_modules/@angular/cdk/bidi/index.d.ts

@@ -0,0 +1,21 @@
+export { B as BidiModule, b as Dir, a as Direction, D as Directionality } from '../bidi-module.d-D-fEBKdS.js';
+import { InjectionToken } from '@angular/core';
+
+/**
+ * Injection token used to inject the document into Directionality.
+ * This is used so that the value can be faked in tests.
+ *
+ * We can't use the real document in tests because changing the real `dir` causes geometry-based
+ * tests in Safari to fail.
+ *
+ * We also can't re-provide the DOCUMENT token from platform-browser because the unit tests
+ * themselves use things like `querySelector` in test code.
+ *
+ * This token is defined in a separate file from Directionality as a workaround for
+ * https://github.com/angular/angular/issues/22559
+ *
+ * @docs-private
+ */
+declare const DIR_DOCUMENT: InjectionToken<Document>;
+
+export { DIR_DOCUMENT };

node_modules/@angular/cdk/clipboard/index.d.ts

@@ -0,0 +1,101 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, EventEmitter } from '@angular/core';
+
+/**
+ * A pending copy-to-clipboard operation.
+ *
+ * The implementation of copying text to the clipboard modifies the DOM and
+ * forces a re-layout. This re-layout can take too long if the string is large,
+ * causing the execCommand('copy') to happen too long after the user clicked.
+ * This results in the browser refusing to copy. This object lets the
+ * re-layout happen in a separate tick from copying by providing a copy function
+ * that can be called later.
+ *
+ * Destroy must be called when no longer in use, regardless of whether `copy` is
+ * called.
+ */
+declare class PendingCopy {
+    private readonly _document;
+    private _textarea;
+    constructor(text: string, _document: Document);
+    /** Finishes copying the text. */
+    copy(): boolean;
+    /** Cleans up DOM changes used to perform the copy operation. */
+    destroy(): void;
+}
+
+/**
+ * A service for copying text to the clipboard.
+ */
+declare class Clipboard {
+    private readonly _document;
+    constructor(...args: unknown[]);
+    /**
+     * Copies the provided text into the user's clipboard.
+     *
+     * @param text The string to copy.
+     * @returns Whether the operation was successful.
+     */
+    copy(text: string): boolean;
+    /**
+     * Prepares a string to be copied later. This is useful for large strings
+     * which take too long to successfully render and be copied in the same tick.
+     *
+     * The caller must call `destroy` on the returned `PendingCopy`.
+     *
+     * @param text The string to copy.
+     * @returns the pending copy operation.
+     */
+    beginCopy(text: string): PendingCopy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Clipboard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Clipboard>;
+}
+
+/** Object that can be used to configure the default options for `CdkCopyToClipboard`. */
+interface CdkCopyToClipboardConfig {
+    /** Default number of attempts to make when copying text to the clipboard. */
+    attempts?: number;
+}
+/** Injection token that can be used to provide the default options to `CdkCopyToClipboard`. */
+declare const CDK_COPY_TO_CLIPBOARD_CONFIG: InjectionToken<CdkCopyToClipboardConfig>;
+/**
+ * Provides behavior for a button that when clicked copies content into user's
+ * clipboard.
+ */
+declare class CdkCopyToClipboard implements OnDestroy {
+    private _clipboard;
+    private _ngZone;
+    /** Content to be copied. */
+    text: string;
+    /**
+     * How many times to attempt to copy the text. This may be necessary for longer text, because
+     * the browser needs time to fill an intermediate textarea element and copy the content.
+     */
+    attempts: number;
+    /**
+     * Emits when some text is copied to the clipboard. The
+     * emitted value indicates whether copying was successful.
+     */
+    readonly copied: EventEmitter<boolean>;
+    /** Copies that are currently being attempted. */
+    private _pending;
+    /** Whether the directive has been destroyed. */
+    private _destroyed;
+    /** Timeout for the current copy attempt. */
+    private _currentTimeout;
+    constructor(...args: unknown[]);
+    /** Copies the current text to the clipboard. */
+    copy(attempts?: number): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkCopyToClipboard, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkCopyToClipboard, "[cdkCopyToClipboard]", never, { "text": { "alias": "cdkCopyToClipboard"; "required": false; }; "attempts": { "alias": "cdkCopyToClipboardAttempts"; "required": false; }; }, { "copied": "cdkCopyToClipboardCopied"; }, never, never, true, never>;
+}
+
+declare class ClipboardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClipboardModule, never, [typeof CdkCopyToClipboard], [typeof CdkCopyToClipboard]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClipboardModule>;
+}
+
+export { CDK_COPY_TO_CLIPBOARD_CONFIG, CdkCopyToClipboard, Clipboard, ClipboardModule, PendingCopy };
+export type { CdkCopyToClipboardConfig };

node_modules/@angular/cdk/coercion/index.d.ts

@@ -0,0 +1,45 @@
+export { N as NumberInput, _ as _isNumberValue, c as coerceNumberProperty } from '../number-property.d-CJVxXUcb.js';
+import { ElementRef } from '@angular/core';
+
+/**
+ * Type describing the allowed values for a boolean input.
+ * @docs-private
+ */
+type BooleanInput = string | boolean | null | undefined;
+/** Coerces a data-bound value (typically a string) to a boolean. */
+declare function coerceBooleanProperty(value: any): boolean;
+
+/** Wraps the provided value in an array, unless the provided value is an array. */
+declare function coerceArray<T>(value: T | T[]): T[];
+declare function coerceArray<T>(value: T | readonly T[]): readonly T[];
+
+/** Coerces a value to a CSS pixel value. */
+declare function coerceCssPixelValue(value: any): string;
+
+/**
+ * Coerces an ElementRef or an Element into an element.
+ * Useful for APIs that can accept either a ref or the native element itself.
+ */
+declare function coerceElement<T>(elementOrRef: ElementRef<T> | T): T;
+
+/**
+ * Coerces a value to an array of trimmed non-empty strings.
+ * Any input that is not an array, `null` or `undefined` will be turned into a string
+ * via `toString()` and subsequently split with the given separator.
+ * `null` and `undefined` will result in an empty array.
+ * This results in the following outcomes:
+ * - `null` -&gt; `[]`
+ * - `[null]` -&gt; `["null"]`
+ * - `["a", "b ", " "]` -&gt; `["a", "b"]`
+ * - `[1, [2, 3]]` -&gt; `["1", "2,3"]`
+ * - `[{ a: 0 }]` -&gt; `["[object Object]"]`
+ * - `{ a: 0 }` -&gt; `["[object", "Object]"]`
+ *
+ * Useful for defining CSS classes or table columns.
+ * @param value the value to coerce into an array of strings
+ * @param separator split-separator if value isn't an array
+ */
+declare function coerceStringArray(value: any, separator?: string | RegExp): string[];
+
+export { coerceArray, coerceBooleanProperty, coerceCssPixelValue, coerceElement, coerceStringArray };
+export type { BooleanInput };

node_modules/@angular/cdk/coercion/private/index.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+
+/**
+ * Given either an Observable or non-Observable value, returns either the original
+ * Observable, or wraps it in an Observable that emits the non-Observable value.
+ */
+declare function coerceObservable<T>(data: T | Observable<T>): Observable<T>;
+
+export { coerceObservable };

node_modules/@angular/cdk/collections/index.d.ts

@@ -0,0 +1,99 @@
+import { Observable } from 'rxjs';
+import { D as DataSource } from '../data-source.d-Bblv7Zvh.js';
+export { C as CollectionViewer, L as ListRange, i as isDataSource } from '../data-source.d-Bblv7Zvh.js';
+import { IterableChanges, ViewContainerRef } from '@angular/core';
+import { _ as _ViewRepeaterItemContext, a as _ViewRepeater, b as _ViewRepeaterItemContextFactory, c as _ViewRepeaterItemValueResolver, d as _ViewRepeaterItemChanged } from '../view-repeater.d-BKljR8u8.js';
+export { h as _VIEW_REPEATER_STRATEGY, g as _ViewRepeaterItemChange, e as _ViewRepeaterItemInsertArgs, f as _ViewRepeaterOperation } from '../view-repeater.d-BKljR8u8.js';
+import { S as SelectionModel } from '../selection-model.d-C_vvNGP-.js';
+export { a as SelectionChange, g as getMultipleValuesInSingleSelectionError } from '../selection-model.d-C_vvNGP-.js';
+export { U as UniqueSelectionDispatcher, a as UniqueSelectionDispatcherListener } from '../unique-selection-dispatcher.d-DSFqf1MM.js';
+
+/** DataSource wrapper for a native array. */
+declare class ArrayDataSource<T> extends DataSource<T> {
+    private _data;
+    constructor(_data: readonly T[] | Observable<readonly T[]>);
+    connect(): Observable<readonly T[]>;
+    disconnect(): void;
+}
+
+/**
+ * A repeater that destroys views when they are removed from a
+ * {@link ViewContainerRef}. When new items are inserted into the container,
+ * the repeater will always construct a new embedded view for each item.
+ *
+ * @template T The type for the embedded view's $implicit property.
+ * @template R The type for the item in each IterableDiffer change record.
+ * @template C The type for the context passed to each embedded view.
+ */
+declare class _DisposeViewRepeaterStrategy<T, R, C extends _ViewRepeaterItemContext<T>> implements _ViewRepeater<T, R, C> {
+    applyChanges(changes: IterableChanges<R>, viewContainerRef: ViewContainerRef, itemContextFactory: _ViewRepeaterItemContextFactory<T, R, C>, itemValueResolver: _ViewRepeaterItemValueResolver<T, R>, itemViewChanged?: _ViewRepeaterItemChanged<R, C>): void;
+    detach(): void;
+}
+
+/**
+ * A repeater that caches views when they are removed from a
+ * {@link ViewContainerRef}. When new items are inserted into the container,
+ * the repeater will reuse one of the cached views instead of creating a new
+ * embedded view. Recycling cached views reduces the quantity of expensive DOM
+ * inserts.
+ *
+ * @template T The type for the embedded view's $implicit property.
+ * @template R The type for the item in each IterableDiffer change record.
+ * @template C The type for the context passed to each embedded view.
+ */
+declare class _RecycleViewRepeaterStrategy<T, R, C extends _ViewRepeaterItemContext<T>> implements _ViewRepeater<T, R, C> {
+    /**
+     * The size of the cache used to store unused views.
+     * Setting the cache size to `0` will disable caching. Defaults to 20 views.
+     */
+    viewCacheSize: number;
+    /**
+     * View cache that stores embedded view instances that have been previously stamped out,
+     * but don't are not currently rendered. The view repeater will reuse these views rather than
+     * creating brand new ones.
+     *
+     * TODO(michaeljamesparsons) Investigate whether using a linked list would improve performance.
+     */
+    private _viewCache;
+    /** Apply changes to the DOM. */
+    applyChanges(changes: IterableChanges<R>, viewContainerRef: ViewContainerRef, itemContextFactory: _ViewRepeaterItemContextFactory<T, R, C>, itemValueResolver: _ViewRepeaterItemValueResolver<T, R>, itemViewChanged?: _ViewRepeaterItemChanged<R, C>): void;
+    detach(): void;
+    /**
+     * Inserts a view for a new item, either from the cache or by creating a new
+     * one. Returns `undefined` if the item was inserted into a cached view.
+     */
+    private _insertView;
+    /** Detaches the view at the given index and inserts into the view cache. */
+    private _detachAndCacheView;
+    /** Moves view at the previous index to the current index. */
+    private _moveView;
+    /**
+     * Cache the given detached view. If the cache is full, the view will be
+     * destroyed.
+     */
+    private _maybeCacheView;
+    /** Inserts a recycled view from the cache at the given index. */
+    private _insertViewFromCache;
+}
+
+/**
+ * Interface for a class that can flatten hierarchical structured data and re-expand the flattened
+ * data back into its original structure. Should be used in conjunction with the cdk-tree.
+ */
+interface TreeDataNodeFlattener<T> {
+    /** Transforms a set of hierarchical structured data into a flattened data array. */
+    flattenNodes(structuredData: any[]): T[];
+    /**
+     * Expands a flattened array of data into its hierarchical form using the provided expansion
+     * model.
+     */
+    expandFlattenedNodes(nodes: T[], expansionModel: SelectionModel<T>): T[];
+    /**
+     * Put node descendants of node in array.
+     * If `onlyExpandable` is true, then only process expandable descendants.
+     */
+    nodeDescendents(node: T, nodes: T[], onlyExpandable: boolean): void;
+}
+
+export { ArrayDataSource, DataSource, SelectionModel, _DisposeViewRepeaterStrategy, _RecycleViewRepeaterStrategy, _ViewRepeater, _ViewRepeaterItemChanged, _ViewRepeaterItemContext, _ViewRepeaterItemContextFactory, _ViewRepeaterItemValueResolver };
+export type { TreeDataNodeFlattener };

node_modules/@angular/cdk/data-source.d-Bblv7Zvh.d.ts

@@ -0,0 +1,43 @@
+import { Observable } from 'rxjs';
+
+/** Represents a range of numbers with a specified start and end. */
+type ListRange = {
+    start: number;
+    end: number;
+};
+/**
+ * Interface for any component that provides a view of some data collection and wants to provide
+ * information regarding the view and any changes made.
+ */
+interface CollectionViewer {
+    /**
+     * A stream that emits whenever the `CollectionViewer` starts looking at a new portion of the
+     * data. The `start` index is inclusive, while the `end` is exclusive.
+     */
+    viewChange: Observable<ListRange>;
+}
+
+declare abstract class DataSource<T> {
+    /**
+     * Connects a collection viewer (such as a data-table) to this data source. Note that
+     * the stream provided will be accessed during change detection and should not directly change
+     * values that are bound in template views.
+     * @param collectionViewer The component that exposes a view over the data provided by this
+     *     data source.
+     * @returns Observable that emits a new value when the data changes.
+     */
+    abstract connect(collectionViewer: CollectionViewer): Observable<readonly T[]>;
+    /**
+     * Disconnects a collection viewer (such as a data-table) from this data source. Can be used
+     * to perform any clean-up or tear-down operations when a view is being destroyed.
+     *
+     * @param collectionViewer The component that exposes a view over the data provided by this
+     *     data source.
+     */
+    abstract disconnect(collectionViewer: CollectionViewer): void;
+}
+/** Checks whether an object is a data source. */
+declare function isDataSource(value: any): value is DataSource<any>;
+
+export { DataSource as D, isDataSource as i };
+export type { CollectionViewer as C, ListRange as L };

node_modules/@angular/cdk/dialog/index.d.ts

@@ -0,0 +1,431 @@
+import * as i0 from '@angular/core';
+import { ViewContainerRef, Injector, StaticProvider, Type, OnDestroy, ElementRef, NgZone, ChangeDetectorRef, ComponentRef, EmbeddedViewRef, TemplateRef, InjectionToken } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { F as FocusOrigin } from '../focus-monitor.d-CvvJeQRc.js';
+import { F as FocusTrapFactory, A as A11yModule } from '../a11y-module.d-DBHGyKoh.js';
+import { B as BasePortalOutlet, h as CdkPortalOutlet, a as ComponentPortal, T as TemplatePortal, D as DomPortal, C as ComponentType, j as PortalModule } from '../portal-directives.d-BoG39gYN.js';
+export { e as ɵɵCdkPortal, i as ɵɵPortalHostDirective, f as ɵɵTemplatePortalDirective } from '../portal-directives.d-BoG39gYN.js';
+import { a as Direction } from '../bidi-module.d-D-fEBKdS.js';
+import { P as PositionStrategy, n as ScrollStrategy, b as OverlayRef, o as OverlayModule } from '../overlay-module.d-B3qEQtts.js';
+import * as _angular_cdk_portal from '@angular/cdk/portal';
+import { O as Overlay } from '../overlay.d-BdoMy0hX.js';
+import '../observers/index.js';
+import '../number-property.d-CJVxXUcb.js';
+import '../scrolling-module.d-ud2XrbF8.js';
+import '../data-source.d-Bblv7Zvh.js';
+import '@angular/common';
+import '../scrolling/index.js';
+import '../platform.d-B3vREl3q.js';
+import '../style-loader.d-BXZfQZTF.js';
+
+/** Options for where to set focus to automatically on dialog open */
+type AutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+/** Valid ARIA roles for a dialog. */
+type DialogRole = 'dialog' | 'alertdialog';
+/** Component that can be used as the container for the dialog. */
+type DialogContainer = BasePortalOutlet & {
+    _focusTrapped?: Observable<void>;
+    _closeInteractionType?: FocusOrigin;
+    _recaptureFocus?: () => void;
+};
+/** Configuration for opening a modal dialog. */
+declare class DialogConfig<D = unknown, R = unknown, C extends DialogContainer = BasePortalOutlet> {
+    /**
+     * Where the attached component should live in Angular's *logical* component tree.
+     * This affects what is available for injection and the change detection order for the
+     * component instantiated inside of the dialog. This does not affect where the dialog
+     * content will be rendered.
+     */
+    viewContainerRef?: ViewContainerRef;
+    /**
+     * Injector used for the instantiation of the component to be attached. If provided,
+     * takes precedence over the injector indirectly provided by `ViewContainerRef`.
+     */
+    injector?: Injector;
+    /** ID for the dialog. If omitted, a unique one will be generated. */
+    id?: string;
+    /** The ARIA role of the dialog element. */
+    role?: DialogRole;
+    /** Optional CSS class or classes applied to the overlay panel. */
+    panelClass?: string | string[];
+    /** Whether the dialog has a backdrop. */
+    hasBackdrop?: boolean;
+    /** Optional CSS class or classes applied to the overlay backdrop. */
+    backdropClass?: string | string[];
+    /** Whether the dialog closes with the escape key or pointer events outside the panel element. */
+    disableClose?: boolean;
+    /** Width of the dialog. */
+    width?: string;
+    /** Height of the dialog. */
+    height?: string;
+    /** Min-width of the dialog. If a number is provided, assumes pixel units. */
+    minWidth?: number | string;
+    /** Min-height of the dialog. If a number is provided, assumes pixel units. */
+    minHeight?: number | string;
+    /** Max-width of the dialog. If a number is provided, assumes pixel units. */
+    maxWidth?: number | string;
+    /** Max-height of the dialog. If a number is provided, assumes pixel units. */
+    maxHeight?: number | string;
+    /** Strategy to use when positioning the dialog. Defaults to centering it on the page. */
+    positionStrategy?: PositionStrategy;
+    /** Data being injected into the child component. */
+    data?: D | null;
+    /** Layout direction for the dialog's content. */
+    direction?: Direction;
+    /** ID of the element that describes the dialog. */
+    ariaDescribedBy?: string | null;
+    /** ID of the element that labels the dialog. */
+    ariaLabelledBy?: string | null;
+    /** Dialog label applied via `aria-label` */
+    ariaLabel?: string | null;
+    /**
+     * Whether this is a modal dialog. Used to set the `aria-modal` attribute. Off by default,
+     * because it can interfere with other overlay-based components (e.g. `mat-select`) and because
+     * it is redundant since the dialog marks all outside content as `aria-hidden` anyway.
+     */
+    ariaModal?: boolean;
+    /**
+     * Where the dialog should focus on open.
+     * @breaking-change 14.0.0 Remove boolean option from autoFocus. Use string or
+     * AutoFocusTarget instead.
+     */
+    autoFocus?: AutoFocusTarget | string | boolean;
+    /**
+     * Whether the dialog should restore focus to the previously-focused element upon closing.
+     * Has the following behavior based on the type that is passed in:
+     * - `boolean` - when true, will return focus to the element that was focused before the dialog
+     *    was opened, otherwise won't restore focus at all.
+     * - `string` - focus will be restored to the first element that matches the CSS selector.
+     * - `HTMLElement` - focus will be restored to the specific element.
+     */
+    restoreFocus?: boolean | string | HTMLElement;
+    /**
+     * Scroll strategy to be used for the dialog. This determines how
+     * the dialog responds to scrolling underneath the panel element.
+     */
+    scrollStrategy?: ScrollStrategy;
+    /**
+     * Whether the dialog should close when the user navigates backwards or forwards through browser
+     * history. This does not apply to navigation via anchor element unless using URL-hash based
+     * routing (`HashLocationStrategy` in the Angular router).
+     */
+    closeOnNavigation?: boolean;
+    /**
+     * Whether the dialog should close when the dialog service is destroyed. This is useful if
+     * another service is wrapping the dialog and is managing the destruction instead.
+     */
+    closeOnDestroy?: boolean;
+    /**
+     * Whether the dialog should close when the underlying overlay is detached. This is useful if
+     * another service is wrapping the dialog and is managing the destruction instead. E.g. an
+     * external detachment can happen as a result of a scroll strategy triggering it or when the
+     * browser location changes.
+     */
+    closeOnOverlayDetachments?: boolean;
+    /**
+     * Alternate `ComponentFactoryResolver` to use when resolving the associated component.
+     * @deprecated No longer used. Will be removed.
+     * @breaking-change 20.0.0
+     */
+    componentFactoryResolver?: unknown;
+    /**
+     * Providers that will be exposed to the contents of the dialog. Can also
+     * be provided as a function in order to generate the providers lazily.
+     */
+    providers?: StaticProvider[] | ((dialogRef: R, config: DialogConfig<D, R, C>, container: C) => StaticProvider[]);
+    /**
+     * Component into which the dialog content will be rendered. Defaults to `CdkDialogContainer`.
+     * A configuration object can be passed in to customize the providers that will be exposed
+     * to the dialog container.
+     */
+    container?: Type<C> | {
+        type: Type<C>;
+        providers: (config: DialogConfig<D, R, C>) => StaticProvider[];
+    };
+    /**
+     * Context that will be passed to template-based dialogs.
+     * A function can be passed in to resolve the context lazily.
+     */
+    templateContext?: Record<string, any> | (() => Record<string, any>);
+}
+
+declare function throwDialogContentAlreadyAttachedError(): void;
+/**
+ * Internal component that wraps user-provided dialog content.
+ * @docs-private
+ */
+declare class CdkDialogContainer<C extends DialogConfig = DialogConfig> extends BasePortalOutlet implements DialogContainer, OnDestroy {
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _focusTrapFactory: FocusTrapFactory;
+    readonly _config: C;
+    private _interactivityChecker;
+    protected _ngZone: NgZone;
+    private _overlayRef;
+    private _focusMonitor;
+    private _renderer;
+    protected readonly _changeDetectorRef: ChangeDetectorRef;
+    private _injector;
+    private _platform;
+    protected _document: Document;
+    /** The portal outlet inside of this container into which the dialog content will be loaded. */
+    _portalOutlet: CdkPortalOutlet;
+    _focusTrapped: Observable<void>;
+    /** The class that traps and manages focus within the dialog. */
+    private _focusTrap;
+    /** Element that was focused before the dialog was opened. Save this to restore upon close. */
+    private _elementFocusedBeforeDialogWasOpened;
+    /**
+     * Type of interaction that led to the dialog being closed. This is used to determine
+     * whether the focus style will be applied when returning focus to its original location
+     * after the dialog is closed.
+     */
+    _closeInteractionType: FocusOrigin | null;
+    /**
+     * Queue of the IDs of the dialog's label element, based on their definition order. The first
+     * ID will be used as the `aria-labelledby` value. We use a queue here to handle the case
+     * where there are two or more titles in the DOM at a time and the first one is destroyed while
+     * the rest are present.
+     */
+    _ariaLabelledByQueue: string[];
+    private _isDestroyed;
+    constructor(...args: unknown[]);
+    _addAriaLabelledBy(id: string): void;
+    _removeAriaLabelledBy(id: string): void;
+    protected _contentAttached(): void;
+    /**
+     * Can be used by child classes to customize the initial focus
+     * capturing behavior (e.g. if it's tied to an animation).
+     */
+    protected _captureInitialFocus(): void;
+    ngOnDestroy(): void;
+    /**
+     * Attach a ComponentPortal as content to this dialog container.
+     * @param portal Portal to be attached as the dialog content.
+     */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    /**
+     * Attach a TemplatePortal as content to this dialog container.
+     * @param portal Portal to be attached as the dialog content.
+     */
+    attachTemplatePortal<T>(portal: TemplatePortal<T>): EmbeddedViewRef<T>;
+    /**
+     * Attaches a DOM portal to the dialog container.
+     * @param portal Portal to be attached.
+     * @deprecated To be turned into a method.
+     * @breaking-change 10.0.0
+     */
+    attachDomPortal: (portal: DomPortal) => void;
+    /** Captures focus if it isn't already inside the dialog. */
+    _recaptureFocus(): void;
+    /**
+     * Focuses the provided element. If the element is not focusable, it will add a tabIndex
+     * attribute to forcefully focus it. The attribute is removed after focus is moved.
+     * @param element The element to focus.
+     */
+    private _forceFocus;
+    /**
+     * Focuses the first element that matches the given selector within the focus trap.
+     * @param selector The CSS selector for the element to set focus to.
+     */
+    private _focusByCssSelector;
+    /**
+     * Moves the focus inside the focus trap. When autoFocus is not set to 'dialog', if focus
+     * cannot be moved then focus will go to the dialog container.
+     */
+    protected _trapFocus(options?: FocusOptions): void;
+    /** Restores focus to the element that was focused before the dialog opened. */
+    private _restoreFocus;
+    /** Focuses the dialog container. */
+    private _focusDialogContainer;
+    /** Returns whether focus is inside the dialog. */
+    private _containsFocus;
+    /** Sets up the focus trap. */
+    private _initializeFocusTrap;
+    /** Sets up the listener that handles clicks on the dialog backdrop. */
+    private _handleBackdropClicks;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDialogContainer<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CdkDialogContainer<any>, "cdk-dialog-container", never, {}, {}, never, never, true, never>;
+}
+
+/** Additional options that can be passed in when closing a dialog. */
+interface DialogCloseOptions {
+    /** Focus original to use when restoring focus. */
+    focusOrigin?: FocusOrigin;
+}
+/**
+ * Reference to a dialog opened via the Dialog service.
+ */
+declare class DialogRef<R = unknown, C = unknown> {
+    readonly overlayRef: OverlayRef;
+    readonly config: DialogConfig<any, DialogRef<R, C>, DialogContainer>;
+    /**
+     * Instance of component opened into the dialog. Will be
+     * null when the dialog is opened using a `TemplateRef`.
+     */
+    readonly componentInstance: C | null;
+    /**
+     * `ComponentRef` of the component opened into the dialog. Will be
+     * null when the dialog is opened using a `TemplateRef`.
+     */
+    readonly componentRef: ComponentRef<C> | null;
+    /** Instance of the container that is rendering out the dialog content. */
+    readonly containerInstance: DialogContainer;
+    /** Whether the user is allowed to close the dialog. */
+    disableClose: boolean | undefined;
+    /** Emits when the dialog has been closed. */
+    readonly closed: Observable<R | undefined>;
+    /** Emits when the backdrop of the dialog is clicked. */
+    readonly backdropClick: Observable<MouseEvent>;
+    /** Emits when on keyboard events within the dialog. */
+    readonly keydownEvents: Observable<KeyboardEvent>;
+    /** Emits on pointer events that happen outside of the dialog. */
+    readonly outsidePointerEvents: Observable<MouseEvent>;
+    /** Unique ID for the dialog. */
+    readonly id: string;
+    /** Subscription to external detachments of the dialog. */
+    private _detachSubscription;
+    constructor(overlayRef: OverlayRef, config: DialogConfig<any, DialogRef<R, C>, DialogContainer>);
+    /**
+     * Close the dialog.
+     * @param result Optional result to return to the dialog opener.
+     * @param options Additional options to customize the closing behavior.
+     */
+    close(result?: R, options?: DialogCloseOptions): void;
+    /** Updates the position of the dialog based on the current position strategy. */
+    updatePosition(): this;
+    /**
+     * Updates the dialog's width and height.
+     * @param width New width of the dialog.
+     * @param height New height of the dialog.
+     */
+    updateSize(width?: string | number, height?: string | number): this;
+    /** Add a CSS class or an array of classes to the overlay pane. */
+    addPanelClass(classes: string | string[]): this;
+    /** Remove a CSS class or an array of classes from the overlay pane. */
+    removePanelClass(classes: string | string[]): this;
+}
+
+declare class Dialog implements OnDestroy {
+    private _overlay;
+    private _injector;
+    private _defaultOptions;
+    private _parentDialog;
+    private _overlayContainer;
+    private _idGenerator;
+    private _openDialogsAtThisLevel;
+    private readonly _afterAllClosedAtThisLevel;
+    private readonly _afterOpenedAtThisLevel;
+    private _ariaHiddenElements;
+    private _scrollStrategy;
+    /** Keeps track of the currently-open dialogs. */
+    get openDialogs(): readonly DialogRef<any, any>[];
+    /** Stream that emits when a dialog has been opened. */
+    get afterOpened(): Subject<DialogRef<any, any>>;
+    /**
+     * Stream that emits when all open dialog have finished closing.
+     * Will emit on subscribe if there are no open dialogs to begin with.
+     */
+    readonly afterAllClosed: Observable<void>;
+    constructor(...args: unknown[]);
+    /**
+     * Opens a modal dialog containing the given component.
+     * @param component Type of the component to load into the dialog.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly-opened dialog.
+     */
+    open<R = unknown, D = unknown, C = unknown>(component: ComponentType<C>, config?: DialogConfig<D, DialogRef<R, C>>): DialogRef<R, C>;
+    /**
+     * Opens a modal dialog containing the given template.
+     * @param template TemplateRef to instantiate as the dialog content.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly-opened dialog.
+     */
+    open<R = unknown, D = unknown, C = unknown>(template: TemplateRef<C>, config?: DialogConfig<D, DialogRef<R, C>>): DialogRef<R, C>;
+    open<R = unknown, D = unknown, C = unknown>(componentOrTemplateRef: ComponentType<C> | TemplateRef<C>, config?: DialogConfig<D, DialogRef<R, C>>): DialogRef<R, C>;
+    /**
+     * Closes all of the currently-open dialogs.
+     */
+    closeAll(): void;
+    /**
+     * Finds an open dialog by its id.
+     * @param id ID to use when looking up the dialog.
+     */
+    getDialogById<R, C>(id: string): DialogRef<R, C> | undefined;
+    ngOnDestroy(): void;
+    /**
+     * Creates an overlay config from a dialog config.
+     * @param config The dialog configuration.
+     * @returns The overlay configuration.
+     */
+    private _getOverlayConfig;
+    /**
+     * Attaches a dialog container to a dialog's already-created overlay.
+     * @param overlay Reference to the dialog's underlying overlay.
+     * @param config The dialog configuration.
+     * @returns A promise resolving to a ComponentRef for the attached container.
+     */
+    private _attachContainer;
+    /**
+     * Attaches the user-provided component to the already-created dialog container.
+     * @param componentOrTemplateRef The type of component being loaded into the dialog,
+     *     or a TemplateRef to instantiate as the content.
+     * @param dialogRef Reference to the dialog being opened.
+     * @param dialogContainer Component that is going to wrap the dialog content.
+     * @param config Configuration used to open the dialog.
+     */
+    private _attachDialogContent;
+    /**
+     * Creates a custom injector to be used inside the dialog. This allows a component loaded inside
+     * of a dialog to close itself and, optionally, to return a value.
+     * @param config Config object that is used to construct the dialog.
+     * @param dialogRef Reference to the dialog being opened.
+     * @param dialogContainer Component that is going to wrap the dialog content.
+     * @param fallbackInjector Injector to use as a fallback when a lookup fails in the custom
+     * dialog injector, if the user didn't provide a custom one.
+     * @returns The custom injector that can be used inside the dialog.
+     */
+    private _createInjector;
+    /**
+     * Removes a dialog from the array of open dialogs.
+     * @param dialogRef Dialog to be removed.
+     * @param emitEvent Whether to emit an event if this is the last dialog.
+     */
+    private _removeOpenDialog;
+    /** Hides all of the content that isn't an overlay from assistive technology. */
+    private _hideNonDialogContentFromAssistiveTechnology;
+    private _getAfterAllClosed;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Dialog, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Dialog>;
+}
+
+declare class DialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogModule, never, [typeof OverlayModule, typeof PortalModule, typeof A11yModule, typeof CdkDialogContainer], [typeof PortalModule, typeof CdkDialogContainer]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DialogModule>;
+}
+
+/** Injection token for the Dialog's ScrollStrategy. */
+declare const DIALOG_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** Injection token for the Dialog's Data. */
+declare const DIALOG_DATA: InjectionToken<any>;
+/** Injection token that can be used to provide default options for the dialog module. */
+declare const DEFAULT_DIALOG_CONFIG: InjectionToken<DialogConfig<unknown, unknown, _angular_cdk_portal.BasePortalOutlet>>;
+/**
+ * @docs-private
+ * @deprecated No longer used. To be removed.
+ * @breaking-change 19.0.0
+ */
+declare function DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay): () => ScrollStrategy;
+/**
+ * @docs-private
+ * @deprecated No longer used. To be removed.
+ * @breaking-change 19.0.0
+ */
+declare const DIALOG_SCROLL_STRATEGY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY;
+};
+
+export { CdkDialogContainer, DEFAULT_DIALOG_CONFIG, DIALOG_DATA, DIALOG_SCROLL_STRATEGY, DIALOG_SCROLL_STRATEGY_PROVIDER, DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY, Dialog, DialogConfig, DialogModule, DialogRef, throwDialogContentAlreadyAttachedError, CdkPortalOutlet as ɵɵCdkPortalOutlet };
+export type { AutoFocusTarget, DialogCloseOptions, DialogContainer, DialogRole };

node_modules/@angular/cdk/drag-drop/index.d.ts

@@ -0,0 +1,1383 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ElementRef, NgZone, OnDestroy, EventEmitter, AfterViewInit, TemplateRef, OnChanges, SimpleChanges, ViewContainerRef, Renderer2 } from '@angular/core';
+import { a as Direction } from '../bidi-module.d-D-fEBKdS.js';
+import { Subject, Observable } from 'rxjs';
+import { ViewportRuler } from '../scrolling/index.js';
+import { N as NumberInput } from '../number-property.d-CJVxXUcb.js';
+import { a as CdkScrollableModule } from '../scrolling-module.d-ud2XrbF8.js';
+export { C as ɵɵCdkScrollable } from '../scrolling-module.d-ud2XrbF8.js';
+import '../data-source.d-Bblv7Zvh.js';
+
+/** Possible values that can be used to configure the drag start delay. */
+type DragStartDelay = number | {
+    touch: number;
+    mouse: number;
+};
+/** Possible axis along which dragging can be locked. */
+type DragAxis = 'x' | 'y';
+/** Function that can be used to constrain the position of a dragged element. */
+type DragConstrainPosition = (point: Point, dragRef: DragRef) => Point;
+/** Possible orientations for a drop list. */
+type DropListOrientation = 'horizontal' | 'vertical' | 'mixed';
+/**
+ * Injection token that can be used to configure the
+ * behavior of the drag&drop-related components.
+ */
+declare const CDK_DRAG_CONFIG: InjectionToken<DragDropConfig>;
+/**
+ * Object that can be used to configure the drag
+ * items and drop lists within a module or a component.
+ */
+interface DragDropConfig extends Partial<DragRefConfig> {
+    lockAxis?: DragAxis;
+    dragStartDelay?: DragStartDelay;
+    constrainPosition?: DragConstrainPosition;
+    previewClass?: string | string[];
+    boundaryElement?: string;
+    rootElementSelector?: string;
+    draggingDisabled?: boolean;
+    sortingDisabled?: boolean;
+    listAutoScrollDisabled?: boolean;
+    listOrientation?: DropListOrientation;
+    zIndex?: number;
+    previewContainer?: 'global' | 'parent';
+}
+
+/**
+ * Reference to a drop list. Used to manipulate or dispose of the container.
+ */
+declare class DropListRef<T = any> {
+    private _dragDropRegistry;
+    private _ngZone;
+    private _viewportRuler;
+    /** Element that the drop list is attached to. */
+    element: HTMLElement | ElementRef<HTMLElement>;
+    /** Whether starting a dragging sequence from this container is disabled. */
+    disabled: boolean;
+    /** Whether sorting items within the list is disabled. */
+    sortingDisabled: boolean;
+    /** Locks the position of the draggable elements inside the container along the specified axis. */
+    lockAxis: 'x' | 'y';
+    /**
+     * Whether auto-scrolling the view when the user
+     * moves their pointer close to the edges is disabled.
+     */
+    autoScrollDisabled: boolean;
+    /** Number of pixels to scroll for each frame when auto-scrolling an element. */
+    autoScrollStep: number;
+    /**
+     * Function that is used to determine whether an item
+     * is allowed to be moved into a drop container.
+     */
+    enterPredicate: (drag: DragRef, drop: DropListRef) => boolean;
+    /** Function that is used to determine whether an item can be sorted into a particular index. */
+    sortPredicate: (index: number, drag: DragRef, drop: DropListRef) => boolean;
+    /** Emits right before dragging has started. */
+    readonly beforeStarted: Subject<void>;
+    /**
+     * Emits when the user has moved a new drag item into this container.
+     */
+    readonly entered: Subject<{
+        item: DragRef;
+        container: DropListRef;
+        currentIndex: number;
+    }>;
+    /**
+     * Emits when the user removes an item from the container
+     * by dragging it into another container.
+     */
+    readonly exited: Subject<{
+        item: DragRef;
+        container: DropListRef;
+    }>;
+    /** Emits when the user drops an item inside the container. */
+    readonly dropped: Subject<{
+        item: DragRef;
+        currentIndex: number;
+        previousIndex: number;
+        container: DropListRef;
+        previousContainer: DropListRef;
+        isPointerOverContainer: boolean;
+        distance: Point;
+        dropPoint: Point;
+        event: MouseEvent | TouchEvent;
+    }>;
+    /** Emits as the user is swapping items while actively dragging. */
+    readonly sorted: Subject<{
+        previousIndex: number;
+        currentIndex: number;
+        container: DropListRef;
+        item: DragRef;
+    }>;
+    /** Emits when a dragging sequence is started in a list connected to the current one. */
+    readonly receivingStarted: Subject<{
+        receiver: DropListRef;
+        initiator: DropListRef;
+        items: DragRef[];
+    }>;
+    /** Emits when a dragging sequence is stopped from a list connected to the current one. */
+    readonly receivingStopped: Subject<{
+        receiver: DropListRef;
+        initiator: DropListRef;
+    }>;
+    /** Arbitrary data that can be attached to the drop list. */
+    data: T;
+    /** Element that is the direct parent of the drag items. */
+    private _container;
+    /** Whether an item in the list is being dragged. */
+    private _isDragging;
+    /** Keeps track of the positions of any parent scrollable elements. */
+    private _parentPositions;
+    /** Strategy being used to sort items within the list. */
+    private _sortStrategy;
+    /** Cached `DOMRect` of the drop list. */
+    private _domRect;
+    /** Draggable items in the container. */
+    private _draggables;
+    /** Drop lists that are connected to the current one. */
+    private _siblings;
+    /** Connected siblings that currently have a dragged item. */
+    private _activeSiblings;
+    /** Subscription to the window being scrolled. */
+    private _viewportScrollSubscription;
+    /** Vertical direction in which the list is currently scrolling. */
+    private _verticalScrollDirection;
+    /** Horizontal direction in which the list is currently scrolling. */
+    private _horizontalScrollDirection;
+    /** Node that is being auto-scrolled. */
+    private _scrollNode;
+    /** Used to signal to the current auto-scroll sequence when to stop. */
+    private readonly _stopScrollTimers;
+    /** Shadow root of the current element. Necessary for `elementFromPoint` to resolve correctly. */
+    private _cachedShadowRoot;
+    /** Reference to the document. */
+    private _document;
+    /** Elements that can be scrolled while the user is dragging. */
+    private _scrollableElements;
+    /** Initial value for the element's `scroll-snap-type` style. */
+    private _initialScrollSnap;
+    /** Direction of the list's layout. */
+    private _direction;
+    constructor(element: ElementRef<HTMLElement> | HTMLElement, _dragDropRegistry: DragDropRegistry, _document: any, _ngZone: NgZone, _viewportRuler: ViewportRuler);
+    /** Removes the drop list functionality from the DOM element. */
+    dispose(): void;
+    /** Whether an item from this list is currently being dragged. */
+    isDragging(): boolean;
+    /** Starts dragging an item. */
+    start(): void;
+    /**
+     * Attempts to move an item into the container.
+     * @param item Item that was moved into the container.
+     * @param pointerX Position of the item along the X axis.
+     * @param pointerY Position of the item along the Y axis.
+     * @param index Index at which the item entered. If omitted, the container will try to figure it
+     *   out automatically.
+     */
+    enter(item: DragRef, pointerX: number, pointerY: number, index?: number): void;
+    /**
+     * Removes an item from the container after it was dragged into another container by the user.
+     * @param item Item that was dragged out.
+     */
+    exit(item: DragRef): void;
+    /**
+     * Drops an item into this container.
+     * @param item Item being dropped into the container.
+     * @param currentIndex Index at which the item should be inserted.
+     * @param previousIndex Index of the item when dragging started.
+     * @param previousContainer Container from which the item got dragged in.
+     * @param isPointerOverContainer Whether the user's pointer was over the
+     *    container when the item was dropped.
+     * @param distance Distance the user has dragged since the start of the dragging sequence.
+     * @param event Event that triggered the dropping sequence.
+     *
+     * @breaking-change 15.0.0 `previousIndex` and `event` parameters to become required.
+     */
+    drop(item: DragRef, currentIndex: number, previousIndex: number, previousContainer: DropListRef, isPointerOverContainer: boolean, distance: Point, dropPoint: Point, event?: MouseEvent | TouchEvent): void;
+    /**
+     * Sets the draggable items that are a part of this list.
+     * @param items Items that are a part of this list.
+     */
+    withItems(items: DragRef[]): this;
+    /** Sets the layout direction of the drop list. */
+    withDirection(direction: Direction): this;
+    /**
+     * Sets the containers that are connected to this one. When two or more containers are
+     * connected, the user will be allowed to transfer items between them.
+     * @param connectedTo Other containers that the current containers should be connected to.
+     */
+    connectedTo(connectedTo: DropListRef[]): this;
+    /**
+     * Sets the orientation of the container.
+     * @param orientation New orientation for the container.
+     */
+    withOrientation(orientation: DropListOrientation): this;
+    /**
+     * Sets which parent elements are can be scrolled while the user is dragging.
+     * @param elements Elements that can be scrolled.
+     */
+    withScrollableParents(elements: HTMLElement[]): this;
+    /**
+     * Configures the drop list so that a different element is used as the container for the
+     * dragged items. This is useful for the cases when one might not have control over the
+     * full DOM that sets up the dragging.
+     * Note that the alternate container needs to be a descendant of the drop list.
+     * @param container New element container to be assigned.
+     */
+    withElementContainer(container: HTMLElement): this;
+    /** Gets the scrollable parents that are registered with this drop container. */
+    getScrollableParents(): readonly HTMLElement[];
+    /**
+     * Figures out the index of an item in the container.
+     * @param item Item whose index should be determined.
+     */
+    getItemIndex(item: DragRef): number;
+    /**
+     * Whether the list is able to receive the item that
+     * is currently being dragged inside a connected drop list.
+     */
+    isReceiving(): boolean;
+    /**
+     * Sorts an item inside the container based on its position.
+     * @param item Item to be sorted.
+     * @param pointerX Position of the item along the X axis.
+     * @param pointerY Position of the item along the Y axis.
+     * @param pointerDelta Direction in which the pointer is moving along each axis.
+     */
+    _sortItem(item: DragRef, pointerX: number, pointerY: number, pointerDelta: {
+        x: number;
+        y: number;
+    }): void;
+    /**
+     * Checks whether the user's pointer is close to the edges of either the
+     * viewport or the drop list and starts the auto-scroll sequence.
+     * @param pointerX User's pointer position along the x axis.
+     * @param pointerY User's pointer position along the y axis.
+     */
+    _startScrollingIfNecessary(pointerX: number, pointerY: number): void;
+    /** Stops any currently-running auto-scroll sequences. */
+    _stopScrolling(): void;
+    /** Starts the dragging sequence within the list. */
+    private _draggingStarted;
+    /** Caches the positions of the configured scrollable parents. */
+    private _cacheParentPositions;
+    /** Resets the container to its initial state. */
+    private _reset;
+    /** Starts the interval that'll auto-scroll the element. */
+    private _startScrollInterval;
+    /**
+     * Checks whether the user's pointer is positioned over the container.
+     * @param x Pointer position along the X axis.
+     * @param y Pointer position along the Y axis.
+     */
+    _isOverContainer(x: number, y: number): boolean;
+    /**
+     * Figures out whether an item should be moved into a sibling
+     * drop container, based on its current position.
+     * @param item Drag item that is being moved.
+     * @param x Position of the item along the X axis.
+     * @param y Position of the item along the Y axis.
+     */
+    _getSiblingContainerFromPosition(item: DragRef, x: number, y: number): DropListRef | undefined;
+    /**
+     * Checks whether the drop list can receive the passed-in item.
+     * @param item Item that is being dragged into the list.
+     * @param x Position of the item along the X axis.
+     * @param y Position of the item along the Y axis.
+     */
+    _canReceive(item: DragRef, x: number, y: number): boolean;
+    /**
+     * Called by one of the connected drop lists when a dragging sequence has started.
+     * @param sibling Sibling in which dragging has started.
+     */
+    _startReceiving(sibling: DropListRef, items: DragRef[]): void;
+    /**
+     * Called by a connected drop list when dragging has stopped.
+     * @param sibling Sibling whose dragging has stopped.
+     */
+    _stopReceiving(sibling: DropListRef): void;
+    /**
+     * Starts listening to scroll events on the viewport.
+     * Used for updating the internal state of the list.
+     */
+    private _listenToScrollEvents;
+    /**
+     * Lazily resolves and returns the shadow root of the element. We do this in a function, rather
+     * than saving it in property directly on init, because we want to resolve it as late as possible
+     * in order to ensure that the element has been moved into the shadow DOM. Doing it inside the
+     * constructor might be too early if the element is inside of something like `ngFor` or `ngIf`.
+     */
+    private _getShadowRoot;
+    /** Notifies any siblings that may potentially receive the item. */
+    private _notifyReceivingSiblings;
+}
+
+/** Container that wraps a set of draggable items. */
+declare class CdkDropList<T = any> implements OnDestroy {
+    element: ElementRef<HTMLElement>;
+    private _changeDetectorRef;
+    private _scrollDispatcher;
+    private _dir;
+    private _group;
+    /** Refs that have been synced with the drop ref most recently. */
+    private _latestSortedRefs;
+    /** Emits when the list has been destroyed. */
+    private readonly _destroyed;
+    /** Whether the element's scrollable parents have been resolved. */
+    private _scrollableParentsResolved;
+    /** Keeps track of the drop lists that are currently on the page. */
+    private static _dropLists;
+    /** Reference to the underlying drop list instance. */
+    _dropListRef: DropListRef<CdkDropList<T>>;
+    /**
+     * Other draggable containers that this container is connected to and into which the
+     * container's items can be transferred. Can either be references to other drop containers,
+     * or their unique IDs.
+     */
+    connectedTo: (CdkDropList | string)[] | CdkDropList | string;
+    /** Arbitrary data to attach to this container. */
+    data: T;
+    /** Direction in which the list is oriented. */
+    orientation: DropListOrientation;
+    /**
+     * Unique ID for the drop zone. Can be used as a reference
+     * in the `connectedTo` of another `CdkDropList`.
+     */
+    id: string;
+    /** Locks the position of the draggable elements inside the container along the specified axis. */
+    lockAxis: DragAxis;
+    /** Whether starting a dragging sequence from this container is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Whether sorting within this drop list is disabled. */
+    sortingDisabled: boolean;
+    /**
+     * Function that is used to determine whether an item
+     * is allowed to be moved into a drop container.
+     */
+    enterPredicate: (drag: CdkDrag, drop: CdkDropList) => boolean;
+    /** Functions that is used to determine whether an item can be sorted into a particular index. */
+    sortPredicate: (index: number, drag: CdkDrag, drop: CdkDropList) => boolean;
+    /** Whether to auto-scroll the view when the user moves their pointer close to the edges. */
+    autoScrollDisabled: boolean;
+    /** Number of pixels to scroll for each frame when auto-scrolling an element. */
+    autoScrollStep: NumberInput;
+    /**
+     * Selector that will be used to resolve an alternate element container for the drop list.
+     * Passing an alternate container is useful for the cases where one might not have control
+     * over the parent node of the draggable items within the list (e.g. due to content projection).
+     * This allows for usages like:
+     *
+     * ```
+     * <div cdkDropList cdkDropListElementContainer=".inner">
+     *   <div class="inner">
+     *     <div cdkDrag></div>
+     *   </div>
+     * </div>
+     * ```
+     */
+    elementContainerSelector: string | null;
+    /** Emits when the user drops an item inside the container. */
+    readonly dropped: EventEmitter<CdkDragDrop<T, any>>;
+    /**
+     * Emits when the user has moved a new drag item into this container.
+     */
+    readonly entered: EventEmitter<CdkDragEnter<T>>;
+    /**
+     * Emits when the user removes an item from the container
+     * by dragging it into another container.
+     */
+    readonly exited: EventEmitter<CdkDragExit<T>>;
+    /** Emits as the user is swapping items while actively dragging. */
+    readonly sorted: EventEmitter<CdkDragSortEvent<T>>;
+    /**
+     * Keeps track of the items that are registered with this container. Historically we used to
+     * do this with a `ContentChildren` query, however queries don't handle transplanted views very
+     * well which means that we can't handle cases like dragging the headers of a `mat-table`
+     * correctly. What we do instead is to have the items register themselves with the container
+     * and then we sort them based on their position in the DOM.
+     */
+    private _unsortedItems;
+    constructor(...args: unknown[]);
+    /** Registers an items with the drop list. */
+    addItem(item: CdkDrag): void;
+    /** Removes an item from the drop list. */
+    removeItem(item: CdkDrag): void;
+    /** Gets the registered items in the list, sorted by their position in the DOM. */
+    getSortedItems(): CdkDrag[];
+    ngOnDestroy(): void;
+    /** Syncs the inputs of the CdkDropList with the options of the underlying DropListRef. */
+    private _setupInputSyncSubscription;
+    /** Handles events from the underlying DropListRef. */
+    private _handleEvents;
+    /** Assigns the default input values based on a provided config object. */
+    private _assignDefaults;
+    /** Syncs up the registered drag items with underlying drop list ref. */
+    private _syncItemsWithRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDropList<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDropList<any>, "[cdkDropList], cdk-drop-list", ["cdkDropList"], { "connectedTo": { "alias": "cdkDropListConnectedTo"; "required": false; }; "data": { "alias": "cdkDropListData"; "required": false; }; "orientation": { "alias": "cdkDropListOrientation"; "required": false; }; "id": { "alias": "id"; "required": false; }; "lockAxis": { "alias": "cdkDropListLockAxis"; "required": false; }; "disabled": { "alias": "cdkDropListDisabled"; "required": false; }; "sortingDisabled": { "alias": "cdkDropListSortingDisabled"; "required": false; }; "enterPredicate": { "alias": "cdkDropListEnterPredicate"; "required": false; }; "sortPredicate": { "alias": "cdkDropListSortPredicate"; "required": false; }; "autoScrollDisabled": { "alias": "cdkDropListAutoScrollDisabled"; "required": false; }; "autoScrollStep": { "alias": "cdkDropListAutoScrollStep"; "required": false; }; "elementContainerSelector": { "alias": "cdkDropListElementContainer"; "required": false; }; }, { "dropped": "cdkDropListDropped"; "entered": "cdkDropListEntered"; "exited": "cdkDropListExited"; "sorted": "cdkDropListSorted"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_sortingDisabled: unknown;
+    static ngAcceptInputType_autoScrollDisabled: unknown;
+}
+
+/** Event emitted when the user starts dragging a draggable. */
+interface CdkDragStart<T = any> {
+    /** Draggable that emitted the event. */
+    source: CdkDrag<T>;
+    /** Native event that started the drag sequence. */
+    event: MouseEvent | TouchEvent;
+}
+/** Event emitted when the user releases an item, before any animations have started. */
+interface CdkDragRelease<T = any> {
+    /** Draggable that emitted the event. */
+    source: CdkDrag<T>;
+    /** Native event that caused the release event. */
+    event: MouseEvent | TouchEvent;
+}
+/** Event emitted when the user stops dragging a draggable. */
+interface CdkDragEnd<T = any> {
+    /** Draggable that emitted the event. */
+    source: CdkDrag<T>;
+    /** Distance in pixels that the user has dragged since the drag sequence started. */
+    distance: {
+        x: number;
+        y: number;
+    };
+    /** Position where the pointer was when the item was dropped */
+    dropPoint: {
+        x: number;
+        y: number;
+    };
+    /** Native event that caused the dragging to stop. */
+    event: MouseEvent | TouchEvent;
+}
+/** Event emitted when the user moves an item into a new drop container. */
+interface CdkDragEnter<T = any, I = T> {
+    /** Container into which the user has moved the item. */
+    container: CdkDropList<T>;
+    /** Item that was moved into the container. */
+    item: CdkDrag<I>;
+    /** Index at which the item has entered the container. */
+    currentIndex: number;
+}
+/**
+ * Event emitted when the user removes an item from a
+ * drop container by moving it into another one.
+ */
+interface CdkDragExit<T = any, I = T> {
+    /** Container from which the user has a removed an item. */
+    container: CdkDropList<T>;
+    /** Item that was removed from the container. */
+    item: CdkDrag<I>;
+}
+/** Event emitted when the user drops a draggable item inside a drop container. */
+interface CdkDragDrop<T, O = T, I = any> {
+    /** Index of the item when it was picked up. */
+    previousIndex: number;
+    /** Current index of the item. */
+    currentIndex: number;
+    /** Item that is being dropped. */
+    item: CdkDrag<I>;
+    /** Container in which the item was dropped. */
+    container: CdkDropList<T>;
+    /** Container from which the item was picked up. Can be the same as the `container`. */
+    previousContainer: CdkDropList<O>;
+    /** Whether the user's pointer was over the container when the item was dropped. */
+    isPointerOverContainer: boolean;
+    /** Distance in pixels that the user has dragged since the drag sequence started. */
+    distance: {
+        x: number;
+        y: number;
+    };
+    /** Position where the pointer was when the item was dropped */
+    dropPoint: {
+        x: number;
+        y: number;
+    };
+    /** Native event that caused the drop event. */
+    event: MouseEvent | TouchEvent;
+}
+/** Event emitted as the user is dragging a draggable item. */
+interface CdkDragMove<T = any> {
+    /** Item that is being dragged. */
+    source: CdkDrag<T>;
+    /** Position of the user's pointer on the page. */
+    pointerPosition: {
+        x: number;
+        y: number;
+    };
+    /** Native event that is causing the dragging. */
+    event: MouseEvent | TouchEvent;
+    /** Distance in pixels that the user has dragged since the drag sequence started. */
+    distance: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Indicates the direction in which the user is dragging the element along each axis.
+     * `1` means that the position is increasing (e.g. the user is moving to the right or downwards),
+     * whereas `-1` means that it's decreasing (they're moving to the left or upwards). `0` means
+     * that the position hasn't changed.
+     */
+    delta: {
+        x: -1 | 0 | 1;
+        y: -1 | 0 | 1;
+    };
+}
+/** Event emitted when the user swaps the position of two drag items. */
+interface CdkDragSortEvent<T = any, I = T> {
+    /** Index from which the item was sorted previously. */
+    previousIndex: number;
+    /** Index that the item is currently in. */
+    currentIndex: number;
+    /** Container that the item belongs to. */
+    container: CdkDropList<T>;
+    /** Item that is being sorted. */
+    item: CdkDrag<I>;
+}
+
+/**
+ * Injection token that can be used to reference instances of `CdkDragHandle`. It serves as
+ * alternative token to the actual `CdkDragHandle` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CDK_DRAG_HANDLE: InjectionToken<CdkDragHandle>;
+/** Handle that can be used to drag a CdkDrag instance. */
+declare class CdkDragHandle implements AfterViewInit, OnDestroy {
+    element: ElementRef<HTMLElement>;
+    private _parentDrag;
+    private _dragDropRegistry;
+    /** Emits when the state of the handle has changed. */
+    readonly _stateChanges: Subject<CdkDragHandle>;
+    /** Whether starting to drag through this handle is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    constructor(...args: unknown[]);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDragHandle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDragHandle, "[cdkDragHandle]", never, { "disabled": { "alias": "cdkDragHandleDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/**
+ * Injection token that can be used to reference instances of `CdkDragPlaceholder`. It serves as
+ * alternative token to the actual `CdkDragPlaceholder` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CDK_DRAG_PLACEHOLDER: InjectionToken<CdkDragPlaceholder<any>>;
+/**
+ * Element that will be used as a template for the placeholder of a CdkDrag when
+ * it is being dragged. The placeholder is displayed in place of the element being dragged.
+ */
+declare class CdkDragPlaceholder<T = any> implements OnDestroy {
+    templateRef: TemplateRef<T>;
+    private _drag;
+    /** Context data to be added to the placeholder template instance. */
+    data: T;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDragPlaceholder<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDragPlaceholder<any>, "ng-template[cdkDragPlaceholder]", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Injection token that can be used to reference instances of `CdkDragPreview`. It serves as
+ * alternative token to the actual `CdkDragPreview` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CDK_DRAG_PREVIEW: InjectionToken<CdkDragPreview<any>>;
+/**
+ * Element that will be used as a template for the preview
+ * of a CdkDrag when it is being dragged.
+ */
+declare class CdkDragPreview<T = any> implements OnDestroy {
+    templateRef: TemplateRef<T>;
+    private _drag;
+    /** Context data to be added to the preview template instance. */
+    data: T;
+    /** Whether the preview should preserve the same size as the item that is being dragged. */
+    matchSize: boolean;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDragPreview<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDragPreview<any>, "ng-template[cdkDragPreview]", never, { "data": { "alias": "data"; "required": false; }; "matchSize": { "alias": "matchSize"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_matchSize: unknown;
+}
+
+/**
+ * Injection token that can be used to reference instances of `CdkDropList`. It serves as
+ * alternative token to the actual `CdkDropList` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CDK_DROP_LIST: InjectionToken<CdkDropList<any>>;
+/** Element that can be moved inside a CdkDropList container. */
+declare class CdkDrag<T = any> implements AfterViewInit, OnChanges, OnDestroy {
+    element: ElementRef<HTMLElement>;
+    dropContainer: CdkDropList<any>;
+    private _ngZone;
+    private _viewContainerRef;
+    private _dir;
+    private _changeDetectorRef;
+    private _selfHandle;
+    private _parentDrag;
+    private _dragDropRegistry;
+    private readonly _destroyed;
+    private _handles;
+    private _previewTemplate;
+    private _placeholderTemplate;
+    /** Reference to the underlying drag instance. */
+    _dragRef: DragRef<CdkDrag<T>>;
+    /** Arbitrary data to attach to this drag instance. */
+    data: T;
+    /** Locks the position of the dragged element along the specified axis. */
+    lockAxis: DragAxis;
+    /**
+     * Selector that will be used to determine the root draggable element, starting from
+     * the `cdkDrag` element and going up the DOM. Passing an alternate root element is useful
+     * when trying to enable dragging on an element that you might not have access to.
+     */
+    rootElementSelector: string;
+    /**
+     * Node or selector that will be used to determine the element to which the draggable's
+     * position will be constrained. If a string is passed in, it'll be used as a selector that
+     * will be matched starting from the element's parent and going up the DOM until a match
+     * has been found.
+     */
+    boundaryElement: string | ElementRef<HTMLElement> | HTMLElement;
+    /**
+     * Amount of milliseconds to wait after the user has put their
+     * pointer down before starting to drag the element.
+     */
+    dragStartDelay: DragStartDelay;
+    /**
+     * Sets the position of a `CdkDrag` that is outside of a drop container.
+     * Can be used to restore the element's position for a returning user.
+     */
+    freeDragPosition: Point;
+    /** Whether starting to drag this element is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /**
+     * Function that can be used to customize the logic of how the position of the drag item
+     * is limited while it's being dragged. Gets called with a point containing the current position
+     * of the user's pointer on the page, a reference to the item being dragged and its dimensions.
+     * Should return a point describing where the item should be rendered.
+     */
+    constrainPosition?: (userPointerPosition: Point, dragRef: DragRef, dimensions: DOMRect, pickupPositionInElement: Point) => Point;
+    /** Class to be added to the preview element. */
+    previewClass: string | string[];
+    /**
+     * Configures the place into which the preview of the item will be inserted. Can be configured
+     * globally through `CDK_DROP_LIST`. Possible values:
+     * - `global` - Preview will be inserted at the bottom of the `<body>`. The advantage is that
+     * you don't have to worry about `overflow: hidden` or `z-index`, but the item won't retain
+     * its inherited styles.
+     * - `parent` - Preview will be inserted into the parent of the drag item. The advantage is that
+     * inherited styles will be preserved, but it may be clipped by `overflow: hidden` or not be
+     * visible due to `z-index`. Furthermore, the preview is going to have an effect over selectors
+     * like `:nth-child` and some flexbox configurations.
+     * - `ElementRef<HTMLElement> | HTMLElement` - Preview will be inserted into a specific element.
+     * Same advantages and disadvantages as `parent`.
+     */
+    previewContainer: PreviewContainer;
+    /**
+     * If the parent of the dragged element has a `scale` transform, it can throw off the
+     * positioning when the user starts dragging. Use this input to notify the CDK of the scale.
+     */
+    scale: number;
+    /** Emits when the user starts dragging the item. */
+    readonly started: EventEmitter<CdkDragStart>;
+    /** Emits when the user has released a drag item, before any animations have started. */
+    readonly released: EventEmitter<CdkDragRelease>;
+    /** Emits when the user stops dragging an item in the container. */
+    readonly ended: EventEmitter<CdkDragEnd>;
+    /** Emits when the user has moved the item into a new container. */
+    readonly entered: EventEmitter<CdkDragEnter<any>>;
+    /** Emits when the user removes the item its container by dragging it into another container. */
+    readonly exited: EventEmitter<CdkDragExit<any>>;
+    /** Emits when the user drops the item inside a container. */
+    readonly dropped: EventEmitter<CdkDragDrop<any>>;
+    /**
+     * Emits as the user is dragging the item. Use with caution,
+     * because this event will fire for every pixel that the user has dragged.
+     */
+    readonly moved: Observable<CdkDragMove<T>>;
+    private _injector;
+    constructor(...args: unknown[]);
+    /**
+     * Returns the element that is being used as a placeholder
+     * while the current element is being dragged.
+     */
+    getPlaceholderElement(): HTMLElement;
+    /** Returns the root draggable element. */
+    getRootElement(): HTMLElement;
+    /** Resets a standalone drag item to its initial position. */
+    reset(): void;
+    /**
+     * Gets the pixel coordinates of the draggable outside of a drop container.
+     */
+    getFreeDragPosition(): Readonly<Point>;
+    /**
+     * Sets the current position in pixels the draggable outside of a drop container.
+     * @param value New position to be set.
+     */
+    setFreeDragPosition(value: Point): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    _addHandle(handle: CdkDragHandle): void;
+    _removeHandle(handle: CdkDragHandle): void;
+    _setPreviewTemplate(preview: CdkDragPreview): void;
+    _resetPreviewTemplate(preview: CdkDragPreview): void;
+    _setPlaceholderTemplate(placeholder: CdkDragPlaceholder): void;
+    _resetPlaceholderTemplate(placeholder: CdkDragPlaceholder): void;
+    /** Syncs the root element with the `DragRef`. */
+    private _updateRootElement;
+    /** Gets the boundary element, based on the `boundaryElement` value. */
+    private _getBoundaryElement;
+    /** Syncs the inputs of the CdkDrag with the options of the underlying DragRef. */
+    private _syncInputs;
+    /** Handles the events from the underlying `DragRef`. */
+    private _handleEvents;
+    /** Assigns the default input values based on a provided config object. */
+    private _assignDefaults;
+    /** Sets up the listener that syncs the handles with the drag ref. */
+    private _setupHandlesListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDrag<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDrag<any>, "[cdkDrag]", ["cdkDrag"], { "data": { "alias": "cdkDragData"; "required": false; }; "lockAxis": { "alias": "cdkDragLockAxis"; "required": false; }; "rootElementSelector": { "alias": "cdkDragRootElement"; "required": false; }; "boundaryElement": { "alias": "cdkDragBoundary"; "required": false; }; "dragStartDelay": { "alias": "cdkDragStartDelay"; "required": false; }; "freeDragPosition": { "alias": "cdkDragFreeDragPosition"; "required": false; }; "disabled": { "alias": "cdkDragDisabled"; "required": false; }; "constrainPosition": { "alias": "cdkDragConstrainPosition"; "required": false; }; "previewClass": { "alias": "cdkDragPreviewClass"; "required": false; }; "previewContainer": { "alias": "cdkDragPreviewContainer"; "required": false; }; "scale": { "alias": "cdkDragScale"; "required": false; }; }, { "started": "cdkDragStarted"; "released": "cdkDragReleased"; "ended": "cdkDragEnded"; "entered": "cdkDragEntered"; "exited": "cdkDragExited"; "dropped": "cdkDragDropped"; "moved": "cdkDragMoved"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_scale: unknown;
+}
+
+/**
+ * Service that keeps track of all the drag item and drop container
+ * instances, and manages global event listeners on the `document`.
+ * @docs-private
+ */
+declare class DragDropRegistry<_ = unknown, __ = unknown> implements OnDestroy {
+    private _ngZone;
+    private _document;
+    private _styleLoader;
+    private _renderer;
+    private _cleanupDocumentTouchmove;
+    /** Registered drop container instances. */
+    private _dropInstances;
+    /** Registered drag item instances. */
+    private _dragInstances;
+    /** Drag item instances that are currently being dragged. */
+    private _activeDragInstances;
+    /** Keeps track of the event listeners that we've bound to the `document`. */
+    private _globalListeners;
+    /**
+     * Predicate function to check if an item is being dragged.  Moved out into a property,
+     * because it'll be called a lot and we don't want to create a new function every time.
+     */
+    private _draggingPredicate;
+    /**
+     * Map tracking DOM nodes and their corresponding drag directives. Note that this is different
+     * from looking through the `_dragInstances` and getting their root node, because the root node
+     * isn't necessarily the node that the directive is set on.
+     */
+    private _domNodesToDirectives;
+    /**
+     * Emits the `touchmove` or `mousemove` events that are dispatched
+     * while the user is dragging a drag item instance.
+     */
+    readonly pointerMove: Subject<TouchEvent | MouseEvent>;
+    /**
+     * Emits the `touchend` or `mouseup` events that are dispatched
+     * while the user is dragging a drag item instance.
+     */
+    readonly pointerUp: Subject<TouchEvent | MouseEvent>;
+    /**
+     * Emits when the viewport has been scrolled while the user is dragging an item.
+     * @deprecated To be turned into a private member. Use the `scrolled` method instead.
+     * @breaking-change 13.0.0
+     */
+    readonly scroll: Subject<Event>;
+    constructor(...args: unknown[]);
+    /** Adds a drop container to the registry. */
+    registerDropContainer(drop: DropListRef): void;
+    /** Adds a drag item instance to the registry. */
+    registerDragItem(drag: DragRef): void;
+    /** Removes a drop container from the registry. */
+    removeDropContainer(drop: DropListRef): void;
+    /** Removes a drag item instance from the registry. */
+    removeDragItem(drag: DragRef): void;
+    /**
+     * Starts the dragging sequence for a drag instance.
+     * @param drag Drag instance which is being dragged.
+     * @param event Event that initiated the dragging.
+     */
+    startDragging(drag: DragRef, event: TouchEvent | MouseEvent): void;
+    /** Stops dragging a drag item instance. */
+    stopDragging(drag: DragRef): void;
+    /** Gets whether a drag item instance is currently being dragged. */
+    isDragging(drag: DragRef): boolean;
+    /**
+     * Gets a stream that will emit when any element on the page is scrolled while an item is being
+     * dragged.
+     * @param shadowRoot Optional shadow root that the current dragging sequence started from.
+     *   Top-level listeners won't pick up events coming from the shadow DOM so this parameter can
+     *   be used to include an additional top-level listener at the shadow root level.
+     */
+    scrolled(shadowRoot?: DocumentOrShadowRoot | null): Observable<Event>;
+    /**
+     * Tracks the DOM node which has a draggable directive.
+     * @param node Node to track.
+     * @param dragRef Drag directive set on the node.
+     */
+    registerDirectiveNode(node: Node, dragRef: CdkDrag): void;
+    /**
+     * Stops tracking a draggable directive node.
+     * @param node Node to stop tracking.
+     */
+    removeDirectiveNode(node: Node): void;
+    /**
+     * Gets the drag directive corresponding to a specific DOM node, if any.
+     * @param node Node for which to do the lookup.
+     */
+    getDragDirectiveForNode(node: Node): CdkDrag | null;
+    ngOnDestroy(): void;
+    /**
+     * Event listener that will prevent the default browser action while the user is dragging.
+     * @param event Event whose default action should be prevented.
+     */
+    private _preventDefaultWhileDragging;
+    /** Event listener for `touchmove` that is bound even if no dragging is happening. */
+    private _persistentTouchmoveListener;
+    /** Clears out the global event listeners from the `document`. */
+    private _clearGlobalListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropRegistry<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragDropRegistry<any, any>>;
+}
+
+/** Template that can be used to create a drag preview element. */
+interface DragPreviewTemplate<T = any> {
+    matchSize?: boolean;
+    template: TemplateRef<T> | null;
+    viewContainer: ViewContainerRef;
+    context: T;
+}
+
+/** Object that can be used to configure the behavior of DragRef. */
+interface DragRefConfig {
+    /**
+     * Minimum amount of pixels that the user should
+     * drag, before the CDK initiates a drag sequence.
+     */
+    dragStartThreshold: number;
+    /**
+     * Amount the pixels the user should drag before the CDK
+     * considers them to have changed the drag direction.
+     */
+    pointerDirectionChangeThreshold: number;
+    /** `z-index` for the absolutely-positioned elements that are created by the drag item. */
+    zIndex?: number;
+    /** Ref that the current drag item is nested in. */
+    parentDragRef?: DragRef;
+}
+/** Template that can be used to create a drag helper element (e.g. a preview or a placeholder). */
+interface DragHelperTemplate<T = any> {
+    template: TemplateRef<T> | null;
+    viewContainer: ViewContainerRef;
+    context: T;
+}
+/** Point on the page or within an element. */
+interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Possible places into which the preview of a drag item can be inserted.
+ * - `global` - Preview will be inserted at the bottom of the `<body>`. The advantage is that
+ * you don't have to worry about `overflow: hidden` or `z-index`, but the item won't retain
+ * its inherited styles.
+ * - `parent` - Preview will be inserted into the parent of the drag item. The advantage is that
+ * inherited styles will be preserved, but it may be clipped by `overflow: hidden` or not be
+ * visible due to `z-index`. Furthermore, the preview is going to have an effect over selectors
+ * like `:nth-child` and some flexbox configurations.
+ * - `ElementRef<HTMLElement> | HTMLElement` - Preview will be inserted into a specific element.
+ * Same advantages and disadvantages as `parent`.
+ */
+type PreviewContainer = 'global' | 'parent' | ElementRef<HTMLElement> | HTMLElement;
+/**
+ * Reference to a draggable item. Used to manipulate or dispose of the item.
+ */
+declare class DragRef<T = any> {
+    private _config;
+    private _document;
+    private _ngZone;
+    private _viewportRuler;
+    private _dragDropRegistry;
+    private _renderer;
+    private _rootElementCleanups;
+    private _cleanupShadowRootSelectStart;
+    /** Element displayed next to the user's pointer while the element is dragged. */
+    private _preview;
+    /** Container into which to insert the preview. */
+    private _previewContainer;
+    /** Reference to the view of the placeholder element. */
+    private _placeholderRef;
+    /** Element that is rendered instead of the draggable item while it is being sorted. */
+    private _placeholder;
+    /** Coordinates within the element at which the user picked up the element. */
+    private _pickupPositionInElement;
+    /** Coordinates on the page at which the user picked up the element. */
+    private _pickupPositionOnPage;
+    /**
+     * Anchor node used to save the place in the DOM where the element was
+     * picked up so that it can be restored at the end of the drag sequence.
+     */
+    private _anchor;
+    /**
+     * CSS `transform` applied to the element when it isn't being dragged. We need a
+     * passive transform in order for the dragged element to retain its new position
+     * after the user has stopped dragging and because we need to know the relative
+     * position in case they start dragging again. This corresponds to `element.style.transform`.
+     */
+    private _passiveTransform;
+    /** CSS `transform` that is applied to the element while it's being dragged. */
+    private _activeTransform;
+    /** Inline `transform` value that the element had before the first dragging sequence. */
+    private _initialTransform?;
+    /**
+     * Whether the dragging sequence has been started. Doesn't
+     * necessarily mean that the element has been moved.
+     */
+    private _hasStartedDragging;
+    /** Whether the element has moved since the user started dragging it. */
+    private _hasMoved;
+    /** Drop container in which the DragRef resided when dragging began. */
+    private _initialContainer;
+    /** Index at which the item started in its initial container. */
+    private _initialIndex;
+    /** Cached positions of scrollable parent elements. */
+    private _parentPositions;
+    /** Emits when the item is being moved. */
+    private readonly _moveEvents;
+    /** Keeps track of the direction in which the user is dragging along each axis. */
+    private _pointerDirectionDelta;
+    /** Pointer position at which the last change in the delta occurred. */
+    private _pointerPositionAtLastDirectionChange;
+    /** Position of the pointer at the last pointer event. */
+    private _lastKnownPointerPosition;
+    /**
+     * Root DOM node of the drag instance. This is the element that will
+     * be moved around as the user is dragging.
+     */
+    private _rootElement;
+    /**
+     * Nearest ancestor SVG, relative to which coordinates are calculated if dragging SVGElement
+     */
+    private _ownerSVGElement;
+    /**
+     * Inline style value of `-webkit-tap-highlight-color` at the time the
+     * dragging was started. Used to restore the value once we're done dragging.
+     */
+    private _rootElementTapHighlight;
+    /** Subscription to pointer movement events. */
+    private _pointerMoveSubscription;
+    /** Subscription to the event that is dispatched when the user lifts their pointer. */
+    private _pointerUpSubscription;
+    /** Subscription to the viewport being scrolled. */
+    private _scrollSubscription;
+    /** Subscription to the viewport being resized. */
+    private _resizeSubscription;
+    /**
+     * Time at which the last touch event occurred. Used to avoid firing the same
+     * events multiple times on touch devices where the browser will fire a fake
+     * mouse event for each touch event, after a certain time.
+     */
+    private _lastTouchEventTime;
+    /** Time at which the last dragging sequence was started. */
+    private _dragStartTime;
+    /** Cached reference to the boundary element. */
+    private _boundaryElement;
+    /** Whether the native dragging interactions have been enabled on the root element. */
+    private _nativeInteractionsEnabled;
+    /** Client rect of the root element when the dragging sequence has started. */
+    private _initialDomRect?;
+    /** Cached dimensions of the preview element. Should be read via `_getPreviewRect`. */
+    private _previewRect?;
+    /** Cached dimensions of the boundary element. */
+    private _boundaryRect?;
+    /** Element that will be used as a template to create the draggable item's preview. */
+    private _previewTemplate?;
+    /** Template for placeholder element rendered to show where a draggable would be dropped. */
+    private _placeholderTemplate?;
+    /** Elements that can be used to drag the draggable item. */
+    private _handles;
+    /** Registered handles that are currently disabled. */
+    private _disabledHandles;
+    /** Droppable container that the draggable is a part of. */
+    private _dropContainer?;
+    /** Layout direction of the item. */
+    private _direction;
+    /** Ref that the current drag item is nested in. */
+    private _parentDragRef;
+    /**
+     * Cached shadow root that the element is placed in. `null` means that the element isn't in
+     * the shadow DOM and `undefined` means that it hasn't been resolved yet. Should be read via
+     * `_getShadowRoot`, not directly.
+     */
+    private _cachedShadowRoot;
+    /** Axis along which dragging is locked. */
+    lockAxis: 'x' | 'y';
+    /**
+     * Amount of milliseconds to wait after the user has put their
+     * pointer down before starting to drag the element.
+     */
+    dragStartDelay: number | {
+        touch: number;
+        mouse: number;
+    };
+    /** Class to be added to the preview element. */
+    previewClass: string | string[] | undefined;
+    /**
+     * If the parent of the dragged element has a `scale` transform, it can throw off the
+     * positioning when the user starts dragging. Use this input to notify the CDK of the scale.
+     */
+    scale: number;
+    /** Whether starting to drag this element is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Emits as the drag sequence is being prepared. */
+    readonly beforeStarted: Subject<void>;
+    /** Emits when the user starts dragging the item. */
+    readonly started: Subject<{
+        source: DragRef;
+        event: MouseEvent | TouchEvent;
+    }>;
+    /** Emits when the user has released a drag item, before any animations have started. */
+    readonly released: Subject<{
+        source: DragRef;
+        event: MouseEvent | TouchEvent;
+    }>;
+    /** Emits when the user stops dragging an item in the container. */
+    readonly ended: Subject<{
+        source: DragRef;
+        distance: Point;
+        dropPoint: Point;
+        event: MouseEvent | TouchEvent;
+    }>;
+    /** Emits when the user has moved the item into a new container. */
+    readonly entered: Subject<{
+        container: DropListRef;
+        item: DragRef;
+        currentIndex: number;
+    }>;
+    /** Emits when the user removes the item its container by dragging it into another container. */
+    readonly exited: Subject<{
+        container: DropListRef;
+        item: DragRef;
+    }>;
+    /** Emits when the user drops the item inside a container. */
+    readonly dropped: Subject<{
+        previousIndex: number;
+        currentIndex: number;
+        item: DragRef;
+        container: DropListRef;
+        previousContainer: DropListRef;
+        distance: Point;
+        dropPoint: Point;
+        isPointerOverContainer: boolean;
+        event: MouseEvent | TouchEvent;
+    }>;
+    /**
+     * Emits as the user is dragging the item. Use with caution,
+     * because this event will fire for every pixel that the user has dragged.
+     */
+    readonly moved: Observable<{
+        source: DragRef;
+        pointerPosition: {
+            x: number;
+            y: number;
+        };
+        event: MouseEvent | TouchEvent;
+        distance: Point;
+        delta: {
+            x: -1 | 0 | 1;
+            y: -1 | 0 | 1;
+        };
+    }>;
+    /** Arbitrary data that can be attached to the drag item. */
+    data: T;
+    /**
+     * Function that can be used to customize the logic of how the position of the drag item
+     * is limited while it's being dragged. Gets called with a point containing the current position
+     * of the user's pointer on the page, a reference to the item being dragged and its dimensions.
+     * Should return a point describing where the item should be rendered.
+     */
+    constrainPosition?: (userPointerPosition: Point, dragRef: DragRef, dimensions: DOMRect, pickupPositionInElement: Point) => Point;
+    constructor(element: ElementRef<HTMLElement> | HTMLElement, _config: DragRefConfig, _document: Document, _ngZone: NgZone, _viewportRuler: ViewportRuler, _dragDropRegistry: DragDropRegistry, _renderer: Renderer2);
+    /**
+     * Returns the element that is being used as a placeholder
+     * while the current element is being dragged.
+     */
+    getPlaceholderElement(): HTMLElement;
+    /** Returns the root draggable element. */
+    getRootElement(): HTMLElement;
+    /**
+     * Gets the currently-visible element that represents the drag item.
+     * While dragging this is the placeholder, otherwise it's the root element.
+     */
+    getVisibleElement(): HTMLElement;
+    /** Registers the handles that can be used to drag the element. */
+    withHandles(handles: (HTMLElement | ElementRef<HTMLElement>)[]): this;
+    /**
+     * Registers the template that should be used for the drag preview.
+     * @param template Template that from which to stamp out the preview.
+     */
+    withPreviewTemplate(template: DragPreviewTemplate | null): this;
+    /**
+     * Registers the template that should be used for the drag placeholder.
+     * @param template Template that from which to stamp out the placeholder.
+     */
+    withPlaceholderTemplate(template: DragHelperTemplate | null): this;
+    /**
+     * Sets an alternate drag root element. The root element is the element that will be moved as
+     * the user is dragging. Passing an alternate root element is useful when trying to enable
+     * dragging on an element that you might not have access to.
+     */
+    withRootElement(rootElement: ElementRef<HTMLElement> | HTMLElement): this;
+    /**
+     * Element to which the draggable's position will be constrained.
+     */
+    withBoundaryElement(boundaryElement: ElementRef<HTMLElement> | HTMLElement | null): this;
+    /** Sets the parent ref that the ref is nested in.  */
+    withParent(parent: DragRef<unknown> | null): this;
+    /** Removes the dragging functionality from the DOM element. */
+    dispose(): void;
+    /** Checks whether the element is currently being dragged. */
+    isDragging(): boolean;
+    /** Resets a standalone drag item to its initial position. */
+    reset(): void;
+    /**
+     * Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.
+     * @param handle Handle element that should be disabled.
+     */
+    disableHandle(handle: HTMLElement): void;
+    /**
+     * Enables a handle, if it has been disabled.
+     * @param handle Handle element to be enabled.
+     */
+    enableHandle(handle: HTMLElement): void;
+    /** Sets the layout direction of the draggable item. */
+    withDirection(direction: Direction): this;
+    /** Sets the container that the item is part of. */
+    _withDropContainer(container: DropListRef): void;
+    /**
+     * Gets the current position in pixels the draggable outside of a drop container.
+     */
+    getFreeDragPosition(): Readonly<Point>;
+    /**
+     * Sets the current position in pixels the draggable outside of a drop container.
+     * @param value New position to be set.
+     */
+    setFreeDragPosition(value: Point): this;
+    /**
+     * Sets the container into which to insert the preview element.
+     * @param value Container into which to insert the preview.
+     */
+    withPreviewContainer(value: PreviewContainer): this;
+    /** Updates the item's sort order based on the last-known pointer position. */
+    _sortFromLastPointerPosition(): void;
+    /** Unsubscribes from the global subscriptions. */
+    private _removeListeners;
+    /** Destroys the preview element and its ViewRef. */
+    private _destroyPreview;
+    /** Destroys the placeholder element and its ViewRef. */
+    private _destroyPlaceholder;
+    /** Handler for the `mousedown`/`touchstart` events. */
+    private _pointerDown;
+    /** Handler that is invoked when the user moves their pointer after they've initiated a drag. */
+    private _pointerMove;
+    /** Handler that is invoked when the user lifts their pointer up, after initiating a drag. */
+    private _pointerUp;
+    /**
+     * Clears subscriptions and stops the dragging sequence.
+     * @param event Browser event object that ended the sequence.
+     */
+    private _endDragSequence;
+    /** Starts the dragging sequence. */
+    private _startDragSequence;
+    /**
+     * Sets up the different variables and subscriptions
+     * that will be necessary for the dragging sequence.
+     * @param referenceElement Element that started the drag sequence.
+     * @param event Browser event object that started the sequence.
+     */
+    private _initializeDragSequence;
+    /** Cleans up the DOM artifacts that were added to facilitate the element being dragged. */
+    private _cleanupDragArtifacts;
+    /**
+     * Updates the item's position in its drop container, or moves it
+     * into a new one, depending on its current drag position.
+     */
+    private _updateActiveDropContainer;
+    /**
+     * Animates the preview element from its current position to the location of the drop placeholder.
+     * @returns Promise that resolves when the animation completes.
+     */
+    private _animatePreviewToPlaceholder;
+    /** Creates an element that will be shown instead of the current element while dragging. */
+    private _createPlaceholderElement;
+    /**
+     * Figures out the coordinates at which an element was picked up.
+     * @param referenceElement Element that initiated the dragging.
+     * @param event Event that initiated the dragging.
+     */
+    private _getPointerPositionInElement;
+    /** Determines the point of the page that was touched by the user. */
+    private _getPointerPositionOnPage;
+    /** Gets the pointer position on the page, accounting for any position constraints. */
+    private _getConstrainedPointerPosition;
+    /** Updates the current drag delta, based on the user's current pointer position on the page. */
+    private _updatePointerDirectionDelta;
+    /** Toggles the native drag interactions, based on how many handles are registered. */
+    private _toggleNativeDragInteractions;
+    /** Removes the manually-added event listeners from the root element. */
+    private _removeRootElementListeners;
+    /**
+     * Applies a `transform` to the root element, taking into account any existing transforms on it.
+     * @param x New transform value along the X axis.
+     * @param y New transform value along the Y axis.
+     */
+    private _applyRootElementTransform;
+    /**
+     * Applies a `transform` to the preview, taking into account any existing transforms on it.
+     * @param x New transform value along the X axis.
+     * @param y New transform value along the Y axis.
+     */
+    private _applyPreviewTransform;
+    /**
+     * Gets the distance that the user has dragged during the current drag sequence.
+     * @param currentPosition Current position of the user's pointer.
+     */
+    private _getDragDistance;
+    /** Cleans up any cached element dimensions that we don't need after dragging has stopped. */
+    private _cleanupCachedDimensions;
+    /**
+     * Checks whether the element is still inside its boundary after the viewport has been resized.
+     * If not, the position is adjusted so that the element fits again.
+     */
+    private _containInsideBoundaryOnResize;
+    /** Gets the drag start delay, based on the event type. */
+    private _getDragStartDelay;
+    /** Updates the internal state of the draggable element when scrolling has occurred. */
+    private _updateOnScroll;
+    /** Gets the scroll position of the viewport. */
+    private _getViewportScrollPosition;
+    /**
+     * Lazily resolves and returns the shadow root of the element. We do this in a function, rather
+     * than saving it in property directly on init, because we want to resolve it as late as possible
+     * in order to ensure that the element has been moved into the shadow DOM. Doing it inside the
+     * constructor might be too early if the element is inside of something like `ngFor` or `ngIf`.
+     */
+    private _getShadowRoot;
+    /** Gets the element into which the drag preview should be inserted. */
+    private _getPreviewInsertionPoint;
+    /** Lazily resolves and returns the dimensions of the preview. */
+    private _getPreviewRect;
+    /** Handles a native `dragstart` event. */
+    private _nativeDragStart;
+    /** Gets a handle that is the target of an event. */
+    private _getTargetHandle;
+}
+
+/**
+ * Service that allows for drag-and-drop functionality to be attached to DOM elements.
+ */
+declare class DragDrop {
+    private _document;
+    private _ngZone;
+    private _viewportRuler;
+    private _dragDropRegistry;
+    private _renderer;
+    constructor(...args: unknown[]);
+    /**
+     * Turns an element into a draggable item.
+     * @param element Element to which to attach the dragging functionality.
+     * @param config Object used to configure the dragging behavior.
+     */
+    createDrag<T = any>(element: ElementRef<HTMLElement> | HTMLElement, config?: DragRefConfig): DragRef<T>;
+    /**
+     * Turns an element into a drop list.
+     * @param element Element to which to attach the drop list functionality.
+     */
+    createDropList<T = any>(element: ElementRef<HTMLElement> | HTMLElement): DropListRef<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDrop, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragDrop>;
+}
+
+/**
+ * Injection token that can be used for a `CdkDrag` to provide itself as a parent to the
+ * drag-specific child directive (`CdkDragHandle`, `CdkDragPreview` etc.). Used primarily
+ * to avoid circular imports.
+ * @docs-private
+ */
+declare const CDK_DRAG_PARENT: InjectionToken<CdkDrag<any>>;
+
+/**
+ * Moves an item one index in an array to another.
+ * @param array Array in which to move the item.
+ * @param fromIndex Starting index of the item.
+ * @param toIndex Index to which the item should be moved.
+ */
+declare function moveItemInArray<T = any>(array: T[], fromIndex: number, toIndex: number): void;
+/**
+ * Moves an item from one array to another.
+ * @param currentArray Array from which to transfer the item.
+ * @param targetArray Array into which to put the item.
+ * @param currentIndex Index of the item in its current array.
+ * @param targetIndex Index at which to insert the item.
+ */
+declare function transferArrayItem<T = any>(currentArray: T[], targetArray: T[], currentIndex: number, targetIndex: number): void;
+/**
+ * Copies an item from one array to another, leaving it in its
+ * original position in current array.
+ * @param currentArray Array from which to copy the item.
+ * @param targetArray Array into which is copy the item.
+ * @param currentIndex Index of the item in its current array.
+ * @param targetIndex Index at which to insert the item.
+ *
+ */
+declare function copyArrayItem<T = any>(currentArray: T[], targetArray: T[], currentIndex: number, targetIndex: number): void;
+
+/**
+ * Injection token that can be used to reference instances of `CdkDropListGroup`. It serves as
+ * alternative token to the actual `CdkDropListGroup` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CDK_DROP_LIST_GROUP: InjectionToken<CdkDropListGroup<unknown>>;
+/**
+ * Declaratively connects sibling `cdkDropList` instances together. All of the `cdkDropList`
+ * elements that are placed inside a `cdkDropListGroup` will be connected to each other
+ * automatically. Can be used as an alternative to the `cdkDropListConnectedTo` input
+ * from `cdkDropList`.
+ */
+declare class CdkDropListGroup<T> implements OnDestroy {
+    /** Drop lists registered inside the group. */
+    readonly _items: Set<T>;
+    /** Whether starting a dragging sequence from inside this group is disabled. */
+    disabled: boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkDropListGroup<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkDropListGroup<any>, "[cdkDropListGroup]", ["cdkDropListGroup"], { "disabled": { "alias": "cdkDropListGroupDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class DragDropModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DragDropModule, never, [typeof CdkDropList, typeof CdkDropListGroup, typeof CdkDrag, typeof CdkDragHandle, typeof CdkDragPreview, typeof CdkDragPlaceholder], [typeof CdkScrollableModule, typeof CdkDropList, typeof CdkDropListGroup, typeof CdkDrag, typeof CdkDragHandle, typeof CdkDragPreview, typeof CdkDragPlaceholder]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DragDropModule>;
+}
+
+export { CDK_DRAG_CONFIG, CDK_DRAG_HANDLE, CDK_DRAG_PARENT, CDK_DRAG_PLACEHOLDER, CDK_DRAG_PREVIEW, CDK_DROP_LIST, CDK_DROP_LIST_GROUP, CdkDrag, CdkDragHandle, CdkDragPlaceholder, CdkDragPreview, CdkDropList, CdkDropListGroup, DragDrop, DragDropModule, DragDropRegistry, DragRef, DropListRef, copyArrayItem, moveItemInArray, transferArrayItem };
+export type { CdkDragDrop, CdkDragEnd, CdkDragEnter, CdkDragExit, CdkDragMove, CdkDragRelease, CdkDragSortEvent, CdkDragStart, DragAxis, DragConstrainPosition, DragDropConfig, DragRefConfig, DragStartDelay, DropListOrientation, Point, PreviewContainer };

node_modules/@angular/cdk/fesm2022/a11y-module-BYox5gpI.mjs

@@ -0,0 +1,952 @@
+import * as i0 from '@angular/core';
+import { inject, Injectable, afterNextRender, NgZone, Injector, ElementRef, booleanAttribute, Directive, Input, InjectionToken, NgModule } from '@angular/core';
+import { C as CdkMonitorFocus } from './focus-monitor-e2l_RpN3.mjs';
+import { DOCUMENT } from '@angular/common';
+import { P as Platform } from './platform-DmdVEw_C.mjs';
+import { c as _getFocusedElementPierceShadowDom } from './shadow-dom-B0oHn41l.mjs';
+import { _ as _CdkPrivateStyleLoader } from './style-loader-Cu9AvjH9.mjs';
+import { _VisuallyHiddenLoader } from './private.mjs';
+import { B as BreakpointObserver } from './breakpoints-observer-CljOfYGy.mjs';
+import { ContentObserver, ObserversModule } from './observers.mjs';
+
+/**
+ * Configuration for the isFocusable method.
+ */
+class IsFocusableConfig {
+    /**
+     * Whether to count an element as focusable even if it is not currently visible.
+     */
+    ignoreVisibility = false;
+}
+// The InteractivityChecker leans heavily on the ally.js accessibility utilities.
+// Methods like `isTabbable` are only covering specific edge-cases for the browsers which are
+// supported.
+/**
+ * Utility for checking the interactivity of an element, such as whether it is focusable or
+ * tabbable.
+ */
+class InteractivityChecker {
+    _platform = inject(Platform);
+    constructor() { }
+    /**
+     * Gets whether an element is disabled.
+     *
+     * @param element Element to be checked.
+     * @returns Whether the element is disabled.
+     */
+    isDisabled(element) {
+        // This does not capture some cases, such as a non-form control with a disabled attribute or
+        // a form control inside of a disabled form, but should capture the most common cases.
+        return element.hasAttribute('disabled');
+    }
+    /**
+     * Gets whether an element is visible for the purposes of interactivity.
+     *
+     * This will capture states like `display: none` and `visibility: hidden`, but not things like
+     * being clipped by an `overflow: hidden` parent or being outside the viewport.
+     *
+     * @returns Whether the element is visible.
+     */
+    isVisible(element) {
+        return hasGeometry(element) && getComputedStyle(element).visibility === 'visible';
+    }
+    /**
+     * Gets whether an element can be reached via Tab key.
+     * Assumes that the element has already been checked with isFocusable.
+     *
+     * @param element Element to be checked.
+     * @returns Whether the element is tabbable.
+     */
+    isTabbable(element) {
+        // Nothing is tabbable on the server 😎
+        if (!this._platform.isBrowser) {
+            return false;
+        }
+        const frameElement = getFrameElement(getWindow(element));
+        if (frameElement) {
+            // Frame elements inherit their tabindex onto all child elements.
+            if (getTabIndexValue(frameElement) === -1) {
+                return false;
+            }
+            // Browsers disable tabbing to an element inside of an invisible frame.
+            if (!this.isVisible(frameElement)) {
+                return false;
+            }
+        }
+        let nodeName = element.nodeName.toLowerCase();
+        let tabIndexValue = getTabIndexValue(element);
+        if (element.hasAttribute('contenteditable')) {
+            return tabIndexValue !== -1;
+        }
+        if (nodeName === 'iframe' || nodeName === 'object') {
+            // The frame or object's content may be tabbable depending on the content, but it's
+            // not possibly to reliably detect the content of the frames. We always consider such
+            // elements as non-tabbable.
+            return false;
+        }
+        // In iOS, the browser only considers some specific elements as tabbable.
+        if (this._platform.WEBKIT && this._platform.IOS && !isPotentiallyTabbableIOS(element)) {
+            return false;
+        }
+        if (nodeName === 'audio') {
+            // Audio elements without controls enabled are never tabbable, regardless
+            // of the tabindex attribute explicitly being set.
+            if (!element.hasAttribute('controls')) {
+                return false;
+            }
+            // Audio elements with controls are by default tabbable unless the
+            // tabindex attribute is set to `-1` explicitly.
+            return tabIndexValue !== -1;
+        }
+        if (nodeName === 'video') {
+            // For all video elements, if the tabindex attribute is set to `-1`, the video
+            // is not tabbable. Note: We cannot rely on the default `HTMLElement.tabIndex`
+            // property as that one is set to `-1` in Chrome, Edge and Safari v13.1. The
+            // tabindex attribute is the source of truth here.
+            if (tabIndexValue === -1) {
+                return false;
+            }
+            // If the tabindex is explicitly set, and not `-1` (as per check before), the
+            // video element is always tabbable (regardless of whether it has controls or not).
+            if (tabIndexValue !== null) {
+                return true;
+            }
+            // Otherwise (when no explicit tabindex is set), a video is only tabbable if it
+            // has controls enabled. Firefox is special as videos are always tabbable regardless
+            // of whether there are controls or not.
+            return this._platform.FIREFOX || element.hasAttribute('controls');
+        }
+        return element.tabIndex >= 0;
+    }
+    /**
+     * Gets whether an element can be focused by the user.
+     *
+     * @param element Element to be checked.
+     * @param config The config object with options to customize this method's behavior
+     * @returns Whether the element is focusable.
+     */
+    isFocusable(element, config) {
+        // Perform checks in order of left to most expensive.
+        // Again, naive approach that does not capture many edge cases and browser quirks.
+        return (isPotentiallyFocusable(element) &&
+            !this.isDisabled(element) &&
+            (config?.ignoreVisibility || this.isVisible(element)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: InteractivityChecker, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: InteractivityChecker, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: InteractivityChecker, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+/**
+ * Returns the frame element from a window object. Since browsers like MS Edge throw errors if
+ * the frameElement property is being accessed from a different host address, this property
+ * should be accessed carefully.
+ */
+function getFrameElement(window) {
+    try {
+        return window.frameElement;
+    }
+    catch {
+        return null;
+    }
+}
+/** Checks whether the specified element has any geometry / rectangles. */
+function hasGeometry(element) {
+    // Use logic from jQuery to check for an invisible element.
+    // See https://github.com/jquery/jquery/blob/master/src/css/hiddenVisibleSelectors.js#L12
+    return !!(element.offsetWidth ||
+        element.offsetHeight ||
+        (typeof element.getClientRects === 'function' && element.getClientRects().length));
+}
+/** Gets whether an element's  */
+function isNativeFormElement(element) {
+    let nodeName = element.nodeName.toLowerCase();
+    return (nodeName === 'input' ||
+        nodeName === 'select' ||
+        nodeName === 'button' ||
+        nodeName === 'textarea');
+}
+/** Gets whether an element is an `<input type="hidden">`. */
+function isHiddenInput(element) {
+    return isInputElement(element) && element.type == 'hidden';
+}
+/** Gets whether an element is an anchor that has an href attribute. */
+function isAnchorWithHref(element) {
+    return isAnchorElement(element) && element.hasAttribute('href');
+}
+/** Gets whether an element is an input element. */
+function isInputElement(element) {
+    return element.nodeName.toLowerCase() == 'input';
+}
+/** Gets whether an element is an anchor element. */
+function isAnchorElement(element) {
+    return element.nodeName.toLowerCase() == 'a';
+}
+/** Gets whether an element has a valid tabindex. */
+function hasValidTabIndex(element) {
+    if (!element.hasAttribute('tabindex') || element.tabIndex === undefined) {
+        return false;
+    }
+    let tabIndex = element.getAttribute('tabindex');
+    return !!(tabIndex && !isNaN(parseInt(tabIndex, 10)));
+}
+/**
+ * Returns the parsed tabindex from the element attributes instead of returning the
+ * evaluated tabindex from the browsers defaults.
+ */
+function getTabIndexValue(element) {
+    if (!hasValidTabIndex(element)) {
+        return null;
+    }
+    // See browser issue in Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
+    const tabIndex = parseInt(element.getAttribute('tabindex') || '', 10);
+    return isNaN(tabIndex) ? -1 : tabIndex;
+}
+/** Checks whether the specified element is potentially tabbable on iOS */
+function isPotentiallyTabbableIOS(element) {
+    let nodeName = element.nodeName.toLowerCase();
+    let inputType = nodeName === 'input' && element.type;
+    return (inputType === 'text' ||
+        inputType === 'password' ||
+        nodeName === 'select' ||
+        nodeName === 'textarea');
+}
+/**
+ * Gets whether an element is potentially focusable without taking current visible/disabled state
+ * into account.
+ */
+function isPotentiallyFocusable(element) {
+    // Inputs are potentially focusable *unless* they're type="hidden".
+    if (isHiddenInput(element)) {
+        return false;
+    }
+    return (isNativeFormElement(element) ||
+        isAnchorWithHref(element) ||
+        element.hasAttribute('contenteditable') ||
+        hasValidTabIndex(element));
+}
+/** Gets the parent window of a DOM node with regards of being inside of an iframe. */
+function getWindow(node) {
+    // ownerDocument is null if `node` itself *is* a document.
+    return (node.ownerDocument && node.ownerDocument.defaultView) || window;
+}
+
+/**
+ * Class that allows for trapping focus within a DOM element.
+ *
+ * This class currently uses a relatively simple approach to focus trapping.
+ * It assumes that the tab order is the same as DOM order, which is not necessarily true.
+ * Things like `tabIndex > 0`, flex `order`, and shadow roots can cause the two to be misaligned.
+ */
+class FocusTrap {
+    _element;
+    _checker;
+    _ngZone;
+    _document;
+    _injector;
+    _startAnchor;
+    _endAnchor;
+    _hasAttached = false;
+    // Event listeners for the anchors. Need to be regular functions so that we can unbind them later.
+    startAnchorListener = () => this.focusLastTabbableElement();
+    endAnchorListener = () => this.focusFirstTabbableElement();
+    /** Whether the focus trap is active. */
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(value) {
+        this._enabled = value;
+        if (this._startAnchor && this._endAnchor) {
+            this._toggleAnchorTabIndex(value, this._startAnchor);
+            this._toggleAnchorTabIndex(value, this._endAnchor);
+        }
+    }
+    _enabled = true;
+    constructor(_element, _checker, _ngZone, _document, deferAnchors = false, 
+    /** @breaking-change 20.0.0 param to become required */
+    _injector) {
+        this._element = _element;
+        this._checker = _checker;
+        this._ngZone = _ngZone;
+        this._document = _document;
+        this._injector = _injector;
+        if (!deferAnchors) {
+            this.attachAnchors();
+        }
+    }
+    /** Destroys the focus trap by cleaning up the anchors. */
+    destroy() {
+        const startAnchor = this._startAnchor;
+        const endAnchor = this._endAnchor;
+        if (startAnchor) {
+            startAnchor.removeEventListener('focus', this.startAnchorListener);
+            startAnchor.remove();
+        }
+        if (endAnchor) {
+            endAnchor.removeEventListener('focus', this.endAnchorListener);
+            endAnchor.remove();
+        }
+        this._startAnchor = this._endAnchor = null;
+        this._hasAttached = false;
+    }
+    /**
+     * Inserts the anchors into the DOM. This is usually done automatically
+     * in the constructor, but can be deferred for cases like directives with `*ngIf`.
+     * @returns Whether the focus trap managed to attach successfully. This may not be the case
+     * if the target element isn't currently in the DOM.
+     */
+    attachAnchors() {
+        // If we're not on the browser, there can be no focus to trap.
+        if (this._hasAttached) {
+            return true;
+        }
+        this._ngZone.runOutsideAngular(() => {
+            if (!this._startAnchor) {
+                this._startAnchor = this._createAnchor();
+                this._startAnchor.addEventListener('focus', this.startAnchorListener);
+            }
+            if (!this._endAnchor) {
+                this._endAnchor = this._createAnchor();
+                this._endAnchor.addEventListener('focus', this.endAnchorListener);
+            }
+        });
+        if (this._element.parentNode) {
+            this._element.parentNode.insertBefore(this._startAnchor, this._element);
+            this._element.parentNode.insertBefore(this._endAnchor, this._element.nextSibling);
+            this._hasAttached = true;
+        }
+        return this._hasAttached;
+    }
+    /**
+     * Waits for the zone to stabilize, then focuses the first tabbable element.
+     * @returns Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfully.
+     */
+    focusInitialElementWhenReady(options) {
+        return new Promise(resolve => {
+            this._executeOnStable(() => resolve(this.focusInitialElement(options)));
+        });
+    }
+    /**
+     * Waits for the zone to stabilize, then focuses
+     * the first tabbable element within the focus trap region.
+     * @returns Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfully.
+     */
+    focusFirstTabbableElementWhenReady(options) {
+        return new Promise(resolve => {
+            this._executeOnStable(() => resolve(this.focusFirstTabbableElement(options)));
+        });
+    }
+    /**
+     * Waits for the zone to stabilize, then focuses
+     * the last tabbable element within the focus trap region.
+     * @returns Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfully.
+     */
+    focusLastTabbableElementWhenReady(options) {
+        return new Promise(resolve => {
+            this._executeOnStable(() => resolve(this.focusLastTabbableElement(options)));
+        });
+    }
+    /**
+     * Get the specified boundary element of the trapped region.
+     * @param bound The boundary to get (start or end of trapped region).
+     * @returns The boundary element.
+     */
+    _getRegionBoundary(bound) {
+        // Contains the deprecated version of selector, for temporary backwards comparability.
+        const markers = this._element.querySelectorAll(`[cdk-focus-region-${bound}], ` + `[cdkFocusRegion${bound}], ` + `[cdk-focus-${bound}]`);
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            for (let i = 0; i < markers.length; i++) {
+                // @breaking-change 8.0.0
+                if (markers[i].hasAttribute(`cdk-focus-${bound}`)) {
+                    console.warn(`Found use of deprecated attribute 'cdk-focus-${bound}', ` +
+                        `use 'cdkFocusRegion${bound}' instead. The deprecated ` +
+                        `attribute will be removed in 8.0.0.`, markers[i]);
+                }
+                else if (markers[i].hasAttribute(`cdk-focus-region-${bound}`)) {
+                    console.warn(`Found use of deprecated attribute 'cdk-focus-region-${bound}', ` +
+                        `use 'cdkFocusRegion${bound}' instead. The deprecated attribute ` +
+                        `will be removed in 8.0.0.`, markers[i]);
+                }
+            }
+        }
+        if (bound == 'start') {
+            return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);
+        }
+        return markers.length
+            ? markers[markers.length - 1]
+            : this._getLastTabbableElement(this._element);
+    }
+    /**
+     * Focuses the element that should be focused when the focus trap is initialized.
+     * @returns Whether focus was moved successfully.
+     */
+    focusInitialElement(options) {
+        // Contains the deprecated version of selector, for temporary backwards comparability.
+        const redirectToElement = this._element.querySelector(`[cdk-focus-initial], ` + `[cdkFocusInitial]`);
+        if (redirectToElement) {
+            // @breaking-change 8.0.0
+            if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
+                redirectToElement.hasAttribute(`cdk-focus-initial`)) {
+                console.warn(`Found use of deprecated attribute 'cdk-focus-initial', ` +
+                    `use 'cdkFocusInitial' instead. The deprecated attribute ` +
+                    `will be removed in 8.0.0`, redirectToElement);
+            }
+            // Warn the consumer if the element they've pointed to
+            // isn't focusable, when not in production mode.
+            if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
+                !this._checker.isFocusable(redirectToElement)) {
+                console.warn(`Element matching '[cdkFocusInitial]' is not focusable.`, redirectToElement);
+            }
+            if (!this._checker.isFocusable(redirectToElement)) {
+                const focusableChild = this._getFirstTabbableElement(redirectToElement);
+                focusableChild?.focus(options);
+                return !!focusableChild;
+            }
+            redirectToElement.focus(options);
+            return true;
+        }
+        return this.focusFirstTabbableElement(options);
+    }
+    /**
+     * Focuses the first tabbable element within the focus trap region.
+     * @returns Whether focus was moved successfully.
+     */
+    focusFirstTabbableElement(options) {
+        const redirectToElement = this._getRegionBoundary('start');
+        if (redirectToElement) {
+            redirectToElement.focus(options);
+        }
+        return !!redirectToElement;
+    }
+    /**
+     * Focuses the last tabbable element within the focus trap region.
+     * @returns Whether focus was moved successfully.
+     */
+    focusLastTabbableElement(options) {
+        const redirectToElement = this._getRegionBoundary('end');
+        if (redirectToElement) {
+            redirectToElement.focus(options);
+        }
+        return !!redirectToElement;
+    }
+    /**
+     * Checks whether the focus trap has successfully been attached.
+     */
+    hasAttached() {
+        return this._hasAttached;
+    }
+    /** Get the first tabbable element from a DOM subtree (inclusive). */
+    _getFirstTabbableElement(root) {
+        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
+            return root;
+        }
+        const children = root.children;
+        for (let i = 0; i < children.length; i++) {
+            const tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE
+                ? this._getFirstTabbableElement(children[i])
+                : null;
+            if (tabbableChild) {
+                return tabbableChild;
+            }
+        }
+        return null;
+    }
+    /** Get the last tabbable element from a DOM subtree (inclusive). */
+    _getLastTabbableElement(root) {
+        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
+            return root;
+        }
+        // Iterate in reverse DOM order.
+        const children = root.children;
+        for (let i = children.length - 1; i >= 0; i--) {
+            const tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE
+                ? this._getLastTabbableElement(children[i])
+                : null;
+            if (tabbableChild) {
+                return tabbableChild;
+            }
+        }
+        return null;
+    }
+    /** Creates an anchor element. */
+    _createAnchor() {
+        const anchor = this._document.createElement('div');
+        this._toggleAnchorTabIndex(this._enabled, anchor);
+        anchor.classList.add('cdk-visually-hidden');
+        anchor.classList.add('cdk-focus-trap-anchor');
+        anchor.setAttribute('aria-hidden', 'true');
+        return anchor;
+    }
+    /**
+     * Toggles the `tabindex` of an anchor, based on the enabled state of the focus trap.
+     * @param isEnabled Whether the focus trap is enabled.
+     * @param anchor Anchor on which to toggle the tabindex.
+     */
+    _toggleAnchorTabIndex(isEnabled, anchor) {
+        // Remove the tabindex completely, rather than setting it to -1, because if the
+        // element has a tabindex, the user might still hit it when navigating with the arrow keys.
+        isEnabled ? anchor.setAttribute('tabindex', '0') : anchor.removeAttribute('tabindex');
+    }
+    /**
+     * Toggles the`tabindex` of both anchors to either trap Tab focus or allow it to escape.
+     * @param enabled: Whether the anchors should trap Tab.
+     */
+    toggleAnchors(enabled) {
+        if (this._startAnchor && this._endAnchor) {
+            this._toggleAnchorTabIndex(enabled, this._startAnchor);
+            this._toggleAnchorTabIndex(enabled, this._endAnchor);
+        }
+    }
+    /** Executes a function when the zone is stable. */
+    _executeOnStable(fn) {
+        // TODO: remove this conditional when injector is required in the constructor.
+        if (this._injector) {
+            afterNextRender(fn, { injector: this._injector });
+        }
+        else {
+            setTimeout(fn);
+        }
+    }
+}
+/**
+ * Factory that allows easy instantiation of focus traps.
+ */
+class FocusTrapFactory {
+    _checker = inject(InteractivityChecker);
+    _ngZone = inject(NgZone);
+    _document = inject(DOCUMENT);
+    _injector = inject(Injector);
+    constructor() {
+        inject(_CdkPrivateStyleLoader).load(_VisuallyHiddenLoader);
+    }
+    /**
+     * Creates a focus-trapped region around the given element.
+     * @param element The element around which focus will be trapped.
+     * @param deferCaptureElements Defers the creation of focus-capturing elements to be done
+     *     manually by the user.
+     * @returns The created focus trap instance.
+     */
+    create(element, deferCaptureElements = false) {
+        return new FocusTrap(element, this._checker, this._ngZone, this._document, deferCaptureElements, this._injector);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FocusTrapFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FocusTrapFactory, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: FocusTrapFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+/** Directive for trapping focus within a region. */
+class CdkTrapFocus {
+    _elementRef = inject(ElementRef);
+    _focusTrapFactory = inject(FocusTrapFactory);
+    /** Underlying FocusTrap instance. */
+    focusTrap;
+    /** Previously focused element to restore focus to upon destroy when using autoCapture. */
+    _previouslyFocusedElement = null;
+    /** Whether the focus trap is active. */
+    get enabled() {
+        return this.focusTrap?.enabled || false;
+    }
+    set enabled(value) {
+        if (this.focusTrap) {
+            this.focusTrap.enabled = value;
+        }
+    }
+    /**
+     * Whether the directive should automatically move focus into the trapped region upon
+     * initialization and return focus to the previous activeElement upon destruction.
+     */
+    autoCapture;
+    constructor() {
+        const platform = inject(Platform);
+        if (platform.isBrowser) {
+            this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
+        }
+    }
+    ngOnDestroy() {
+        this.focusTrap?.destroy();
+        // If we stored a previously focused element when using autoCapture, return focus to that
+        // element now that the trapped region is being destroyed.
+        if (this._previouslyFocusedElement) {
+            this._previouslyFocusedElement.focus();
+            this._previouslyFocusedElement = null;
+        }
+    }
+    ngAfterContentInit() {
+        this.focusTrap?.attachAnchors();
+        if (this.autoCapture) {
+            this._captureFocus();
+        }
+    }
+    ngDoCheck() {
+        if (this.focusTrap && !this.focusTrap.hasAttached()) {
+            this.focusTrap.attachAnchors();
+        }
+    }
+    ngOnChanges(changes) {
+        const autoCaptureChange = changes['autoCapture'];
+        if (autoCaptureChange &&
+            !autoCaptureChange.firstChange &&
+            this.autoCapture &&
+            this.focusTrap?.hasAttached()) {
+            this._captureFocus();
+        }
+    }
+    _captureFocus() {
+        this._previouslyFocusedElement = _getFocusedElementPierceShadowDom();
+        this.focusTrap?.focusInitialElementWhenReady();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CdkTrapFocus, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "19.2.6", type: CdkTrapFocus, isStandalone: true, selector: "[cdkTrapFocus]", inputs: { enabled: ["cdkTrapFocus", "enabled", booleanAttribute], autoCapture: ["cdkTrapFocusAutoCapture", "autoCapture", booleanAttribute] }, exportAs: ["cdkTrapFocus"], usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CdkTrapFocus, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkTrapFocus]',
+                    exportAs: 'cdkTrapFocus',
+                }]
+        }], ctorParameters: () => [], propDecorators: { enabled: [{
+                type: Input,
+                args: [{ alias: 'cdkTrapFocus', transform: booleanAttribute }]
+            }], autoCapture: [{
+                type: Input,
+                args: [{ alias: 'cdkTrapFocusAutoCapture', transform: booleanAttribute }]
+            }] } });
+
+const LIVE_ANNOUNCER_ELEMENT_TOKEN = new InjectionToken('liveAnnouncerElement', {
+    providedIn: 'root',
+    factory: LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY,
+});
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+function LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY() {
+    return null;
+}
+/** Injection token that can be used to configure the default options for the LiveAnnouncer. */
+const LIVE_ANNOUNCER_DEFAULT_OPTIONS = new InjectionToken('LIVE_ANNOUNCER_DEFAULT_OPTIONS');
+
+let uniqueIds = 0;
+class LiveAnnouncer {
+    _ngZone = inject(NgZone);
+    _defaultOptions = inject(LIVE_ANNOUNCER_DEFAULT_OPTIONS, {
+        optional: true,
+    });
+    _liveElement;
+    _document = inject(DOCUMENT);
+    _previousTimeout;
+    _currentPromise;
+    _currentResolve;
+    constructor() {
+        const elementToken = inject(LIVE_ANNOUNCER_ELEMENT_TOKEN, { optional: true });
+        this._liveElement = elementToken || this._createLiveElement();
+    }
+    announce(message, ...args) {
+        const defaultOptions = this._defaultOptions;
+        let politeness;
+        let duration;
+        if (args.length === 1 && typeof args[0] === 'number') {
+            duration = args[0];
+        }
+        else {
+            [politeness, duration] = args;
+        }
+        this.clear();
+        clearTimeout(this._previousTimeout);
+        if (!politeness) {
+            politeness =
+                defaultOptions && defaultOptions.politeness ? defaultOptions.politeness : 'polite';
+        }
+        if (duration == null && defaultOptions) {
+            duration = defaultOptions.duration;
+        }
+        // TODO: ensure changing the politeness works on all environments we support.
+        this._liveElement.setAttribute('aria-live', politeness);
+        if (this._liveElement.id) {
+            this._exposeAnnouncerToModals(this._liveElement.id);
+        }
+        // This 100ms timeout is necessary for some browser + screen-reader combinations:
+        // - Both JAWS and NVDA over IE11 will not announce anything without a non-zero timeout.
+        // - With Chrome and IE11 with NVDA or JAWS, a repeated (identical) message won't be read a
+        //   second time without clearing and then using a non-zero delay.
+        // (using JAWS 17 at time of this writing).
+        return this._ngZone.runOutsideAngular(() => {
+            if (!this._currentPromise) {
+                this._currentPromise = new Promise(resolve => (this._currentResolve = resolve));
+            }
+            clearTimeout(this._previousTimeout);
+            this._previousTimeout = setTimeout(() => {
+                this._liveElement.textContent = message;
+                if (typeof duration === 'number') {
+                    this._previousTimeout = setTimeout(() => this.clear(), duration);
+                }
+                // For some reason in tests this can be undefined
+                // Probably related to ZoneJS and every other thing that patches browser APIs in tests
+                this._currentResolve?.();
+                this._currentPromise = this._currentResolve = undefined;
+            }, 100);
+            return this._currentPromise;
+        });
+    }
+    /**
+     * Clears the current text from the announcer element. Can be used to prevent
+     * screen readers from reading the text out again while the user is going
+     * through the page landmarks.
+     */
+    clear() {
+        if (this._liveElement) {
+            this._liveElement.textContent = '';
+        }
+    }
+    ngOnDestroy() {
+        clearTimeout(this._previousTimeout);
+        this._liveElement?.remove();
+        this._liveElement = null;
+        this._currentResolve?.();
+        this._currentPromise = this._currentResolve = undefined;
+    }
+    _createLiveElement() {
+        const elementClass = 'cdk-live-announcer-element';
+        const previousElements = this._document.getElementsByClassName(elementClass);
+        const liveEl = this._document.createElement('div');
+        // Remove any old containers. This can happen when coming in from a server-side-rendered page.
+        for (let i = 0; i < previousElements.length; i++) {
+            previousElements[i].remove();
+        }
+        liveEl.classList.add(elementClass);
+        liveEl.classList.add('cdk-visually-hidden');
+        liveEl.setAttribute('aria-atomic', 'true');
+        liveEl.setAttribute('aria-live', 'polite');
+        liveEl.id = `cdk-live-announcer-${uniqueIds++}`;
+        this._document.body.appendChild(liveEl);
+        return liveEl;
+    }
+    /**
+     * Some browsers won't expose the accessibility node of the live announcer element if there is an
+     * `aria-modal` and the live announcer is outside of it. This method works around the issue by
+     * pointing the `aria-owns` of all modals to the live announcer element.
+     */
+    _exposeAnnouncerToModals(id) {
+        // TODO(http://github.com/angular/components/issues/26853): consider de-duplicating this with
+        // the `SnakBarContainer` and other usages.
+        //
+        // Note that the selector here is limited to CDK overlays at the moment in order to reduce the
+        // section of the DOM we need to look through. This should cover all the cases we support, but
+        // the selector can be expanded if it turns out to be too narrow.
+        const modals = this._document.querySelectorAll('body > .cdk-overlay-container [aria-modal="true"]');
+        for (let i = 0; i < modals.length; i++) {
+            const modal = modals[i];
+            const ariaOwns = modal.getAttribute('aria-owns');
+            if (!ariaOwns) {
+                modal.setAttribute('aria-owns', id);
+            }
+            else if (ariaOwns.indexOf(id) === -1) {
+                modal.setAttribute('aria-owns', ariaOwns + ' ' + id);
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: LiveAnnouncer, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: LiveAnnouncer, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: LiveAnnouncer, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+/**
+ * A directive that works similarly to aria-live, but uses the LiveAnnouncer to ensure compatibility
+ * with a wider range of browsers and screen readers.
+ */
+class CdkAriaLive {
+    _elementRef = inject(ElementRef);
+    _liveAnnouncer = inject(LiveAnnouncer);
+    _contentObserver = inject(ContentObserver);
+    _ngZone = inject(NgZone);
+    /** The aria-live politeness level to use when announcing messages. */
+    get politeness() {
+        return this._politeness;
+    }
+    set politeness(value) {
+        this._politeness = value === 'off' || value === 'assertive' ? value : 'polite';
+        if (this._politeness === 'off') {
+            if (this._subscription) {
+                this._subscription.unsubscribe();
+                this._subscription = null;
+            }
+        }
+        else if (!this._subscription) {
+            this._subscription = this._ngZone.runOutsideAngular(() => {
+                return this._contentObserver.observe(this._elementRef).subscribe(() => {
+                    // Note that we use textContent here, rather than innerText, in order to avoid a reflow.
+                    const elementText = this._elementRef.nativeElement.textContent;
+                    // The `MutationObserver` fires also for attribute
+                    // changes which we don't want to announce.
+                    if (elementText !== this._previousAnnouncedText) {
+                        this._liveAnnouncer.announce(elementText, this._politeness, this.duration);
+                        this._previousAnnouncedText = elementText;
+                    }
+                });
+            });
+        }
+    }
+    _politeness = 'polite';
+    /** Time in milliseconds after which to clear out the announcer element. */
+    duration;
+    _previousAnnouncedText;
+    _subscription;
+    constructor() {
+        inject(_CdkPrivateStyleLoader).load(_VisuallyHiddenLoader);
+    }
+    ngOnDestroy() {
+        if (this._subscription) {
+            this._subscription.unsubscribe();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CdkAriaLive, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.6", type: CdkAriaLive, isStandalone: true, selector: "[cdkAriaLive]", inputs: { politeness: ["cdkAriaLive", "politeness"], duration: ["cdkAriaLiveDuration", "duration"] }, exportAs: ["cdkAriaLive"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: CdkAriaLive, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkAriaLive]',
+                    exportAs: 'cdkAriaLive',
+                }]
+        }], ctorParameters: () => [], propDecorators: { politeness: [{
+                type: Input,
+                args: ['cdkAriaLive']
+            }], duration: [{
+                type: Input,
+                args: ['cdkAriaLiveDuration']
+            }] } });
+
+/** Set of possible high-contrast mode backgrounds. */
+var HighContrastMode;
+(function (HighContrastMode) {
+    HighContrastMode[HighContrastMode["NONE"] = 0] = "NONE";
+    HighContrastMode[HighContrastMode["BLACK_ON_WHITE"] = 1] = "BLACK_ON_WHITE";
+    HighContrastMode[HighContrastMode["WHITE_ON_BLACK"] = 2] = "WHITE_ON_BLACK";
+})(HighContrastMode || (HighContrastMode = {}));
+/** CSS class applied to the document body when in black-on-white high-contrast mode. */
+const BLACK_ON_WHITE_CSS_CLASS = 'cdk-high-contrast-black-on-white';
+/** CSS class applied to the document body when in white-on-black high-contrast mode. */
+const WHITE_ON_BLACK_CSS_CLASS = 'cdk-high-contrast-white-on-black';
+/** CSS class applied to the document body when in high-contrast mode. */
+const HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS = 'cdk-high-contrast-active';
+/**
+ * Service to determine whether the browser is currently in a high-contrast-mode environment.
+ *
+ * Microsoft Windows supports an accessibility feature called "High Contrast Mode". This mode
+ * changes the appearance of all applications, including web applications, to dramatically increase
+ * contrast.
+ *
+ * IE, Edge, and Firefox currently support this mode. Chrome does not support Windows High Contrast
+ * Mode. This service does not detect high-contrast mode as added by the Chrome "High Contrast"
+ * browser extension.
+ */
+class HighContrastModeDetector {
+    _platform = inject(Platform);
+    /**
+     * Figuring out the high contrast mode and adding the body classes can cause
+     * some expensive layouts. This flag is used to ensure that we only do it once.
+     */
+    _hasCheckedHighContrastMode;
+    _document = inject(DOCUMENT);
+    _breakpointSubscription;
+    constructor() {
+        this._breakpointSubscription = inject(BreakpointObserver)
+            .observe('(forced-colors: active)')
+            .subscribe(() => {
+            if (this._hasCheckedHighContrastMode) {
+                this._hasCheckedHighContrastMode = false;
+                this._applyBodyHighContrastModeCssClasses();
+            }
+        });
+    }
+    /** Gets the current high-contrast-mode for the page. */
+    getHighContrastMode() {
+        if (!this._platform.isBrowser) {
+            return HighContrastMode.NONE;
+        }
+        // Create a test element with an arbitrary background-color that is neither black nor
+        // white; high-contrast mode will coerce the color to either black or white. Also ensure that
+        // appending the test element to the DOM does not affect layout by absolutely positioning it
+        const testElement = this._document.createElement('div');
+        testElement.style.backgroundColor = 'rgb(1,2,3)';
+        testElement.style.position = 'absolute';
+        this._document.body.appendChild(testElement);
+        // Get the computed style for the background color, collapsing spaces to normalize between
+        // browsers. Once we get this color, we no longer need the test element. Access the `window`
+        // via the document so we can fake it in tests. Note that we have extra null checks, because
+        // this logic will likely run during app bootstrap and throwing can break the entire app.
+        const documentWindow = this._document.defaultView || window;
+        const computedStyle = documentWindow && documentWindow.getComputedStyle
+            ? documentWindow.getComputedStyle(testElement)
+            : null;
+        const computedColor = ((computedStyle && computedStyle.backgroundColor) || '').replace(/ /g, '');
+        testElement.remove();
+        switch (computedColor) {
+            // Pre Windows 11 dark theme.
+            case 'rgb(0,0,0)':
+            // Windows 11 dark themes.
+            case 'rgb(45,50,54)':
+            case 'rgb(32,32,32)':
+                return HighContrastMode.WHITE_ON_BLACK;
+            // Pre Windows 11 light theme.
+            case 'rgb(255,255,255)':
+            // Windows 11 light theme.
+            case 'rgb(255,250,239)':
+                return HighContrastMode.BLACK_ON_WHITE;
+        }
+        return HighContrastMode.NONE;
+    }
+    ngOnDestroy() {
+        this._breakpointSubscription.unsubscribe();
+    }
+    /** Applies CSS classes indicating high-contrast mode to document body (browser-only). */
+    _applyBodyHighContrastModeCssClasses() {
+        if (!this._hasCheckedHighContrastMode && this._platform.isBrowser && this._document.body) {
+            const bodyClasses = this._document.body.classList;
+            bodyClasses.remove(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, BLACK_ON_WHITE_CSS_CLASS, WHITE_ON_BLACK_CSS_CLASS);
+            this._hasCheckedHighContrastMode = true;
+            const mode = this.getHighContrastMode();
+            if (mode === HighContrastMode.BLACK_ON_WHITE) {
+                bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, BLACK_ON_WHITE_CSS_CLASS);
+            }
+            else if (mode === HighContrastMode.WHITE_ON_BLACK) {
+                bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, WHITE_ON_BLACK_CSS_CLASS);
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: HighContrastModeDetector, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: HighContrastModeDetector, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: HighContrastModeDetector, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class A11yModule {
+    constructor() {
+        inject(HighContrastModeDetector)._applyBodyHighContrastModeCssClasses();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: A11yModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.6", ngImport: i0, type: A11yModule, imports: [ObserversModule, CdkAriaLive, CdkTrapFocus, CdkMonitorFocus], exports: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: A11yModule, imports: [ObserversModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.6", ngImport: i0, type: A11yModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ObserversModule, CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],
+                    exports: [CdkAriaLive, CdkTrapFocus, CdkMonitorFocus],
+                }]
+        }], ctorParameters: () => [] });
+
+export { A11yModule as A, CdkTrapFocus as C, FocusTrapFactory as F, HighContrastModeDetector as H, InteractivityChecker as I, LiveAnnouncer as L, FocusTrap as a, HighContrastMode as b, IsFocusableConfig as c, CdkAriaLive as d, LIVE_ANNOUNCER_ELEMENT_TOKEN as e, LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY as f, LIVE_ANNOUNCER_DEFAULT_OPTIONS as g };
+//# sourceMappingURL=a11y-module-BYox5gpI.mjs.map