Full Code of TracerBench/tracerbench for AI

gitextract_usnw11yz/

├── .github/
│   ├── dependabot.yml
│   └── workflows/
│       └── test-and-lint.yml
├── .gitignore
├── .husky/
│   ├── .gitignore
│   └── pre-push
├── .prettierrc
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE.md
├── NOISE_MITIGATION.md
├── NOTICE.md
├── README.md
├── commitlint.config.js
├── docs/
│   ├── tb.sketch
│   ├── travis-example.js
│   └── travis-example.yml
├── lerna.json
├── package.json
└── packages/
    ├── cli/
    │   ├── .eslintrc.js
    │   ├── .gitignore
    │   ├── .mocharc.json
    │   ├── .prettierrc
    │   ├── LICENSE.md
    │   ├── README.md
    │   ├── bin/
    │   │   ├── run
    │   │   └── run.cmd
    │   ├── markdown/
    │   │   ├── commands.md
    │   │   ├── compare.md
    │   │   ├── help.md
    │   │   ├── profile.md
    │   │   └── record-har.md
    │   ├── oclif.manifest.json
    │   ├── package.json
    │   ├── src/
    │   │   ├── command-config/
    │   │   │   ├── build-config.ts
    │   │   │   ├── default-flag-args.ts
    │   │   │   ├── index.ts
    │   │   │   ├── tb-base.ts
    │   │   │   └── tb-config.ts
    │   │   ├── commands/
    │   │   │   ├── compare/
    │   │   │   │   ├── analyze.ts
    │   │   │   │   ├── index.ts
    │   │   │   │   └── report.ts
    │   │   │   └── record-har/
    │   │   │       ├── auth.ts
    │   │   │       └── index.ts
    │   │   ├── compare/
    │   │   │   ├── compare-results.ts
    │   │   │   ├── generate-stats.ts
    │   │   │   ├── index.ts
    │   │   │   ├── parse-compare-result.ts
    │   │   │   ├── print-to-pdf.ts
    │   │   │   └── tb-table.ts
    │   │   ├── helpers/
    │   │   │   ├── args.ts
    │   │   │   ├── device-lookup.ts
    │   │   │   ├── device-settings.ts
    │   │   │   ├── flags.ts
    │   │   │   ├── index.ts
    │   │   │   └── utils.ts
    │   │   ├── index.ts
    │   │   └── static/
    │   │       ├── chart-bootstrap.css
    │   │       ├── index.ts
    │   │       ├── phase-chart-js-partial.hbs
    │   │       ├── phase-detail-partial.hbs
    │   │       ├── report-template.hbs
    │   │       └── tb-bootstrap.css
    │   ├── tb-schema.json
    │   ├── test/
    │   │   ├── command-config/
    │   │   │   └── build-config.test.ts
    │   │   ├── commands/
    │   │   │   ├── analyze.test.ts
    │   │   │   ├── auth.test.ts
    │   │   │   ├── compare.test.ts
    │   │   │   ├── record-har.test.ts
    │   │   │   └── report.test.ts
    │   │   ├── compare/
    │   │   │   ├── compare-results.test.ts
    │   │   │   ├── generate-stats.test.ts
    │   │   │   ├── parse-compare-result.test.ts
    │   │   │   ├── print-to-pdf.test.ts
    │   │   │   └── tb-table.test.ts
    │   │   ├── fixtures/
    │   │   │   ├── experiment/
    │   │   │   │   ├── app.js
    │   │   │   │   ├── ember.prod.js
    │   │   │   │   ├── index.html
    │   │   │   │   └── tbconfig.json
    │   │   │   ├── regression/
    │   │   │   │   ├── app.js
    │   │   │   │   ├── ember.prod.js
    │   │   │   │   ├── index.html
    │   │   │   │   └── tbconfig.json
    │   │   │   ├── release/
    │   │   │   │   ├── app.js
    │   │   │   │   ├── ember.prod.js
    │   │   │   │   ├── index.html
    │   │   │   │   └── tbconfig.json
    │   │   │   └── results/
    │   │   │       ├── compare.json
    │   │   │       ├── fixture.har
    │   │   │       ├── mock-cookies.json
    │   │   │       ├── mock-trace.json
    │   │   │       ├── report.json
    │   │   │       └── stats.ts
    │   │   ├── helpers/
    │   │   │   ├── simulate-device-options.test.ts
    │   │   │   └── utils.test.ts
    │   │   ├── setup.ts
    │   │   ├── tbconfig.json
    │   │   ├── tbconfig_base.json
    │   │   ├── test-helpers.ts
    │   │   └── tsconfig.json
    │   └── tsconfig.json
    ├── core/
    │   ├── .eslintrc.js
    │   ├── .prettierrc
    │   ├── LICENSE.md
    │   ├── README.md
    │   ├── bin/
    │   │   ├── ResultSets.R
    │   │   ├── plot.R
    │   │   ├── report.R
    │   │   └── runtime-stats.R
    │   ├── package.json
    │   ├── src/
    │   │   ├── create-isolated-page-benchmark.ts
    │   │   ├── create-trace-benchmark.ts
    │   │   ├── create-trace-navigation-benchmark.ts
    │   │   ├── index.ts
    │   │   ├── metrics/
    │   │   │   └── extract-navigation-sample.ts
    │   │   ├── run.ts
    │   │   ├── trace/
    │   │   │   ├── archive-trace.ts
    │   │   │   ├── auth.ts
    │   │   │   ├── conditions.ts
    │   │   │   ├── index.ts
    │   │   │   └── utils.ts
    │   │   ├── tsconfig.json
    │   │   └── util/
    │   │       ├── gc.ts
    │   │       ├── inject-mark-observer.ts
    │   │       ├── interfaces.ts
    │   │       ├── is-navigation-timing-mark.ts
    │   │       ├── navigate.ts
    │   │       ├── read-handle.ts
    │   │       ├── run-trace.ts
    │   │       └── setup-page.ts
    │   ├── test/
    │   │   ├── build/
    │   │   │   ├── build.ts
    │   │   │   ├── compile_templates.ts
    │   │   │   ├── copy_jquery.ts
    │   │   │   ├── download_embers.ts
    │   │   │   ├── index.ts
    │   │   │   ├── make_precompile.ts
    │   │   │   └── util.ts
    │   │   ├── fixtures/
    │   │   │   ├── app.js
    │   │   │   ├── index.html
    │   │   │   └── templates/
    │   │   │       ├── application.hbs
    │   │   │       ├── components/
    │   │   │       │   ├── component-render.hbs
    │   │   │       │   └── nested-component.hbs
    │   │   │       └── index.hbs
    │   │   ├── killTestServer.sh
    │   │   ├── test-server.ts
    │   │   ├── test.ts
    │   │   ├── trace/
    │   │   │   └── trace-utils-test.ts
    │   │   └── tsconfig.json
    │   ├── tsconfig.json
    │   └── tsconfig_base.json
    ├── har/
    │   ├── LICENSE.md
    │   ├── README.md
    │   ├── package.json
    │   └── scripts/
    │       └── generate.js
    ├── har-remix/
    │   ├── .eslintrc.js
    │   ├── LICENSE.md
    │   ├── README.md
    │   ├── package.json
    │   ├── src/
    │   │   ├── archive-server.ts
    │   │   ├── index.ts
    │   │   └── interfaces.ts
    │   └── tsconfig.json
    ├── stats/
    │   ├── .editorconfig
    │   ├── .eslintignore
    │   ├── .eslintrc.js
    │   ├── .gitignore
    │   ├── .mocharc.json
    │   ├── .prettierrc
    │   ├── LICENSE.md
    │   ├── README.md
    │   ├── api-extractor.json
    │   ├── etc/
    │   │   └── stats.api.md
    │   ├── markdown/
    │   │   ├── index.md
    │   │   ├── stats.cartesianproduct.md
    │   │   ├── stats.confidenceinterval.md
    │   │   ├── stats.convertmicrosecondstoms.md
    │   │   ├── stats.convertmstomicroseconds.md
    │   │   ├── stats.getwilcoxonranksumtest.md
    │   │   ├── stats.getwilcoxonsignedranktest.md
    │   │   ├── stats.iaspercentage.md
    │   │   ├── stats.iconfidenceinterval.md
    │   │   ├── stats.ioutliers.iqr.md
    │   │   ├── stats.ioutliers.loweroutlier.md
    │   │   ├── stats.ioutliers.md
    │   │   ├── stats.ioutliers.outliers.md
    │   │   ├── stats.ioutliers.upperoutlier.md
    │   │   ├── stats.isevenfiguresummary.md
    │   │   ├── stats.istatsoptions.confidencelevel.md
    │   │   ├── stats.istatsoptions.control.md
    │   │   ├── stats.istatsoptions.experiment.md
    │   │   ├── stats.istatsoptions.md
    │   │   ├── stats.istatsoptions.name.md
    │   │   ├── stats.md
    │   │   ├── stats.roundfloatandconvertmicrosecondstoms.md
    │   │   ├── stats.stats._constructor_.md
    │   │   ├── stats.stats.buckets.md
    │   │   ├── stats.stats.confidenceinterval.md
    │   │   ├── stats.stats.confidenceintervals.md
    │   │   ├── stats.stats.control.md
    │   │   ├── stats.stats.controlsorted.md
    │   │   ├── stats.stats.estimator.md
    │   │   ├── stats.stats.experiment.md
    │   │   ├── stats.stats.experimentsorted.md
    │   │   ├── stats.stats.md
    │   │   ├── stats.stats.name.md
    │   │   ├── stats.stats.outliers.md
    │   │   ├── stats.stats.populationvariance.md
    │   │   ├── stats.stats.range.md
    │   │   ├── stats.stats.samplecount.md
    │   │   ├── stats.stats.sevenfiguresummary.md
    │   │   ├── stats.stats.sparkline.md
    │   │   └── stats.tonearesthundreth.md
    │   ├── package.json
    │   ├── src/
    │   │   ├── confidence-interval.ts
    │   │   ├── index.ts
    │   │   ├── stats.ts
    │   │   ├── utils.ts
    │   │   ├── wilcoxon-rank-sum.ts
    │   │   └── wilcoxon-signed-rank.ts
    │   ├── temp/
    │   │   ├── stats.api.json
    │   │   └── stats.api.md
    │   ├── test/
    │   │   ├── confidence-interval.test.ts
    │   │   ├── fixtures.ts
    │   │   ├── stats.test.ts
    │   │   ├── tsconfig.json
    │   │   ├── utils.test.ts
    │   │   ├── wilcoxon-rank-sum.test.ts
    │   │   └── wilcoxon-signed-rank.test.ts
    │   ├── tsconfig.json
    │   └── types/
    │       └── jstat/
    │           └── index.d.ts
    ├── trace-event/
    │   ├── .eslintrc.js
    │   ├── LICENSE.md
    │   ├── README.md
    │   ├── package.json
    │   ├── src/
    │   │   ├── constants.ts
    │   │   ├── index.ts
    │   │   └── types.ts
    │   └── tsconfig.json
    └── trace-model/
        ├── .eslintrc.js
        ├── LICENSE.md
        ├── README.md
        ├── package.json
        ├── src/
        │   ├── builders/
        │   │   ├── build-model.ts
        │   │   ├── event-model-impl.ts
        │   │   ├── model-builder.ts
        │   │   ├── process-builder.ts
        │   │   └── thread-builder.ts
        │   ├── index.ts
        │   ├── types.ts
        │   └── util/
        │       ├── bounds.ts
        │       ├── cache.ts
        │       ├── merge-end-event.ts
        │       ├── normalize-complete-events.ts
        │       └── split-cat.ts
        ├── test/
        │   └── test.js
        └── tsconfig.json

SYMBOL INDEX (9327 symbols across 82 files)

FILE: docs/travis-example.js
  function tbAnalyze (line 47) | function tbAnalyze() {

FILE: packages/cli/src/command-config/build-config.ts
  function getCommandDefaults (line 23) | function getCommandDefaults(flags: OutputFlags<any>): OutputFlags<any> {
  function readConfig (line 39) | function readConfig(fileOrDir = "tbconfig.json"): ITBConfig | undefined {
  function resolveConfigFileKeys (line 68) | function resolveConfigFileKeys(config: ITBConfig, configDir = process.cw...
  function resolveFileKeys (line 78) | function resolveFileKeys<K extends string>(
  function resolveConfigFile (line 91) | function resolveConfigFile(fileOrDir: string): [string, string] {
  function handleExplicitFlags (line 107) | function handleExplicitFlags(
  function getConfig (line 131) | function getConfig(

FILE: packages/cli/src/command-config/default-flag-args.ts
  type PerformanceTimingMark (line 10) | type PerformanceTimingMark = keyof PerformanceNavigationTiming;
  function getDefaultValue (line 59) | function getDefaultValue(key: string): any {

FILE: packages/cli/src/command-config/tb-base.ts
  method constructor (line 12) | constructor(argv: string[], config: IConfig) {

FILE: packages/cli/src/command-config/tb-config.ts
  constant CONTROL_ENV_OVERRIDE_ATTR (line 6) | const CONTROL_ENV_OVERRIDE_ATTR = "controlBenchmarkEnvironment";
  constant EXPERIMENT_ENV_OVERRIDE_ATTR (line 7) | const EXPERIMENT_ENV_OVERRIDE_ATTR = "experimentBenchmarkEnvironment";
  constant EXTENDS (line 8) | const EXTENDS = "extends";
  type ITBConfig (line 10) | interface ITBConfig {
  type IHARServer (line 50) | interface IHARServer {
  type IBenchmarkEnvironmentOverride (line 58) | interface IBenchmarkEnvironmentOverride {
  type RegressionThresholdStat (line 66) | type RegressionThresholdStat = "estimator" | "ci-lower" | "ci-upper";

FILE: packages/cli/src/commands/compare/analyze.ts
  type CompareAnalyzeFlags (line 25) | interface CompareAnalyzeFlags {
  class CompareAnalyze (line 33) | class CompareAnalyze extends TBBaseCommand {
    method constructor (line 45) | constructor(argv: string[], config: IConfig) {
    method parseFlags (line 50) | private parseFlags(CompareAnalyze: Parser.Input<any>): CompareAnalyzeF...
    method run (line 79) | public async run(): Promise<string> {
    method getReportTitles (line 118) | private getReportTitles(

FILE: packages/cli/src/commands/compare/index.ts
  type ICompareFlags (line 71) | interface ICompareFlags {
  class Compare (line 95) | class Compare extends TBBaseCommand {
    method constructor (line 130) | constructor(argv: string[], config: IConfig) {
    method init (line 138) | public async init(): Promise<void> {
    method run (line 145) | public async run(): Promise<string> {
    method parseFlags (line 280) | private async parseFlags(): Promise<void> {
    method generateControlExperimentServerConfig (line 341) | private generateControlExperimentServerConfig(): [

FILE: packages/cli/src/commands/compare/report.ts
  constant ARTIFACT_FILE_NAME (line 62) | const ARTIFACT_FILE_NAME = "artifact";
  type IReportFlags (line 65) | interface IReportFlags {
  class CompareReport (line 72) | class CompareReport extends TBBaseCommand {
    method constructor (line 84) | constructor(argv: string[], config: IConfig) {
    method init (line 91) | public async init(): Promise<void> {
    method run (line 98) | public async run(): Promise<void> {
    method logReportPaths (line 115) | private logReportPaths(
    method printPDF (line 128) | private async printPDF(
    method parseFlags (line 166) | private async parseFlags(): Promise<void> {
    method determineOutputFileNamePrefix (line 179) | private determineOutputFileNamePrefix(outputFolder: string): string {
    method createConsumableHTML (line 199) | private createConsumableHTML(
    method resolveTitles (line 239) | public static resolveTitles(

FILE: packages/cli/src/commands/record-har/auth.ts
  type RecordHARAuthOptions (line 22) | type RecordHARAuthOptions = {
  class RecordHARAuth (line 35) | class RecordHARAuth extends TBBaseCommand {
    method init (line 50) | public async init(): Promise<void> {
    method run (line 56) | public async run(): Promise<Protocol.Network.CookieParam[]> {

FILE: packages/cli/src/commands/record-har/index.ts
  class RecordHAR (line 23) | class RecordHAR extends TBBaseCommand {
    method init (line 38) | public async init(): Promise<void> {
    method run (line 43) | public async run(): Promise<void> {
    method validateHAR (line 132) | public async validateHAR(harJSON: Archive, url: string): Promise<void> {
    method getURLfromHAR (line 147) | public getURLfromHAR(harJSON: Archive): string {

FILE: packages/cli/src/compare/compare-results.ts
  type ICompareJSONResult (line 15) | interface ICompareJSONResult {
  type ICompareJSONResults (line 29) | interface ICompareJSONResults {
  type PhaseResultsFormatted (line 37) | type PhaseResultsFormatted = Array<
  class CompareResults (line 51) | class CompareResults {
    method constructor (line 62) | constructor(
    method logMetaMessagesAndWarnings (line 98) | private logMetaMessagesAndWarnings(): void {
    method logStatSummaryReport (line 115) | private logStatSummaryReport(): void {
    method anyResultsSignificant (line 163) | public anyResultsSignificant(
    method allBelowRegressionThreshold (line 177) | public allBelowRegressionThreshold(): boolean {
    method stringifyJSON (line 238) | public stringifyJSON(): string {
    method logTables (line 254) | public logTables(): void {
    method logSummary (line 261) | public logSummary(): void {

FILE: packages/cli/src/compare/generate-stats.ts
  type ParsedTitleConfigs (line 9) | interface ParsedTitleConfigs {
  type Sample (line 15) | type Sample = {
  type ITracerBenchTraceResult (line 25) | interface ITracerBenchTraceResult {
  type FormattedStatsSamples (line 35) | type FormattedStatsSamples = {
  type Frequency (line 45) | type Frequency = {
  type HTMLSectionRenderData (line 51) | interface HTMLSectionRenderData {
  type ValuesByPhase (line 69) | type ValuesByPhase = {
  type ValueGen (line 73) | type ValueGen = {
  type CumulativeData (line 78) | type CumulativeData = {
  class GenerateStats (line 85) | class GenerateStats {
    method constructor (line 92) | constructor(
    method generateData (line 115) | private generateData(
    method bucketPhaseValues (line 164) | private bucketPhaseValues(
    method formatPhaseData (line 191) | private formatPhaseData(
    method bucketCumulative (line 257) | private bucketCumulative(

FILE: packages/cli/src/compare/parse-compare-result.ts
  function parseCompareResult (line 10) | function parseCompareResult(inputFilePath: string): {

FILE: packages/cli/src/compare/print-to-pdf.ts
  function printToPDF (line 14) | async function printToPDF(
  function chromePrintToPDF (line 34) | async function chromePrintToPDF(

FILE: packages/cli/src/compare/tb-table.ts
  class TBTable (line 9) | class TBTable {
    method constructor (line 16) | constructor(heading: string) {
    method getData (line 31) | public getData(): ICompareJSONResult[] {
    method render (line 67) | public render(): string {
    method setTableData (line 72) | private setTableData(): Table.Table {

FILE: packages/cli/src/helpers/device-lookup.ts
  type IDeviceLookup (line 1) | interface IDeviceLookup {
  type IModes (line 26) | interface IModes {

FILE: packages/cli/src/helpers/device-settings.ts
  type ScreenDimensions (line 7) | interface ScreenDimensions {
  type Screens (line 12) | interface Screens {
  type EmulateDeviceSettingBase (line 19) | interface EmulateDeviceSettingBase {
  type EmulateDeviceSetting (line 26) | interface EmulateDeviceSetting {
  type EmulateDeviceSettingCliOption (line 32) | interface EmulateDeviceSettingCliOption
  function getEmulateDeviceSettingForKeyAndOrientation (line 57) | function getEmulateDeviceSettingForKeyAndOrientation(

FILE: packages/cli/src/helpers/utils.ts
  function checkEnvironmentSpecificOverride (line 25) | function checkEnvironmentSpecificOverride(
  function mergeLeft (line 54) | function mergeLeft(
  function convertMicrosecondsToMS (line 75) | function convertMicrosecondsToMS(ms: string | number): number {
  function convertMSToMicroseconds (line 80) | function convertMSToMicroseconds(ms: string | number): number {
  function parseMarkers (line 85) | function parseMarkers(m: string | string[]): Marker[] {
  function convertToTypable (line 112) | function convertToTypable(name: string): string {
  function toNearestHundreth (line 120) | function toNearestHundreth(n: number): number {
  function logHeading (line 148) | function logHeading(
  function timestamp (line 177) | function timestamp(): number {
  function durationInSec (line 181) | function durationInSec(endTime: number, startTime: number): number {
  function secondsToTime (line 185) | function secondsToTime(sec: number): string {
  function md5sum (line 196) | function md5sum(text: string): string {
  function sleep (line 205) | function sleep(ms: number): Promise<void> {

FILE: packages/cli/src/static/index.ts
  constant CHART_CSS_PATH (line 4) | const CHART_CSS_PATH = join(__dirname, "chart-bootstrap.css");
  constant TB_CSS_PATH (line 5) | const TB_CSS_PATH = join(__dirname, "tb-bootstrap.css");
  constant CHART_JS_PATH (line 6) | const CHART_JS_PATH = join(__dirname, "chartjs-2.9.3-chart.min.js");
  constant REPORT_PATH (line 7) | const REPORT_PATH = join(__dirname, "report-template.hbs");
  constant PHASE_DETAIL_PARTIAL (line 8) | const PHASE_DETAIL_PARTIAL = join(__dirname, "phase-detail-partial.hbs");
  constant PHASE_CHART_JS_PARTIAL (line 9) | const PHASE_CHART_JS_PARTIAL = join(__dirname, "phase-chart-js-partial.h...
  constant CHART_CSS (line 10) | const CHART_CSS = readFileSync(CHART_CSS_PATH, "utf8");
  constant TB_CSS (line 11) | const TB_CSS = readFileSync(TB_CSS_PATH, "utf8");
  constant CHART_JS (line 12) | const CHART_JS = readFileSync(CHART_JS_PATH, "utf8");
  constant PHASE_DETAIL_TEMPLATE_RAW (line 13) | const PHASE_DETAIL_TEMPLATE_RAW = readFileSync(PHASE_DETAIL_PARTIAL, "ut...
  constant PHASE_CHART_JS_TEMPLATE_RAW (line 14) | const PHASE_CHART_JS_TEMPLATE_RAW = readFileSync(
  constant REPORT_TEMPLATE_RAW (line 19) | let REPORT_TEMPLATE_RAW = readFileSync(REPORT_PATH, "utf8");

FILE: packages/cli/test/commands/record-har.test.ts
  constant FILENAME (line 12) | const FILENAME = "foo";

FILE: packages/cli/test/commands/report.test.ts
  constant COMPARE (line 17) | const COMPARE = {

FILE: packages/cli/test/compare/compare-results.test.ts
  constant REPORT_TITLES (line 17) | const REPORT_TITLES: ParsedTitleConfigs = {
  constant DEFAULT_REGRESSION_THRESHOLD (line 53) | const DEFAULT_REGRESSION_THRESHOLD = 50;
  constant CONTROL_DATA (line 54) | const CONTROL_DATA: ITracerBenchTraceResult = readJsonSync(COMPARE_JSON)...
  constant EXPERIMENT_DATA (line 55) | const EXPERIMENT_DATA: ITracerBenchTraceResult = readJsonSync(COMPARE_JS...

FILE: packages/cli/test/compare/generate-stats.test.ts
  constant REPORT_TITLES (line 12) | const REPORT_TITLES: ParsedTitleConfigs = {
  constant CONTROL_DATA (line 18) | const CONTROL_DATA: ITracerBenchTraceResult = readJsonSync(COMPARE_JSON)...
  constant EXPERIMENT_DATA (line 19) | const EXPERIMENT_DATA: ITracerBenchTraceResult = readJsonSync(COMPARE_JS...

FILE: packages/cli/test/compare/tb-table.test.ts
  constant TABLE (line 16) | const TABLE = new TBTable("Foo Table");

FILE: packages/cli/test/fixtures/experiment/app.js
  function renderEnd (line 11) | function renderEnd() {

FILE: packages/cli/test/fixtures/experiment/ember.prod.js
  function missingModule (line 19) | function missingModule(name, referrerName) {
  function internalRequire (line 27) | function internalRequire(_name, referrerName) {
  method log (line 182) | log() {
  method warn (line 204) | warn() {
  method error (line 226) | error() {
  method info (line 249) | info() {
  method debug (line 272) | debug() {
  method assert (line 300) | assert() {
  method hasContainers (line 333) | hasContainers() {
  method reset (line 337) | reset() {
  class Container (line 363) | class Container {
    method constructor (line 364) | constructor(registry, options = {}) {
    method lookup (line 426) | lookup(fullName, options) {
    method destroy (line 438) | destroy() {
    method finalizeDestroy (line 442) | finalizeDestroy() {
    method reset (line 452) | reset(fullName) {
    method ownerInjection (line 468) | ownerInjection() {
    method factoryFor (line 483) | factoryFor(fullName, options = {}) {
  function wrapManagerInDeprecationProxy (line 506) | function wrapManagerInDeprecationProxy(manager) {
  function isSingleton (line 528) | function isSingleton(container, fullName) {
  function isInstantiatable (line 531) | function isInstantiatable(container, fullName) {
  function lookup (line 534) | function lookup(container, fullName, options = {}) {
  function factoryFor (line 552) | function factoryFor(container, normalizedName, fullName) {
  function isSingletonClass (line 571) | function isSingletonClass(container, fullName, { instantiate, singleton ...
  function isSingletonInstance (line 574) | function isSingletonInstance(container, fullName, { instantiate, singlet...
  function isFactoryClass (line 577) | function isFactoryClass(container, fullname, { instantiate, singleton }) {
  function isFactoryInstance (line 580) | function isFactoryInstance(container, fullName, { instantiate, singleton...
  function instantiateFactory (line 583) | function instantiateFactory(container, normalizedName, fullName, options) {
  function processInjections (line 603) | function processInjections(container, injections, result) {
  function buildInjections (line 623) | function buildInjections(container, typeInjections, injections) {
  function injectionsFor (line 636) | function injectionsFor(container, fullName) {
  function destroyDestroyables (line 643) | function destroyDestroyables(container) {
  function resetCache (line 654) | function resetCache(container) {
  function resetMember (line 658) | function resetMember(container, fullName) {
  class FactoryManager (line 669) | class FactoryManager {
    method constructor (line 670) | constructor(container, factory, fullName, normalizedName) {
    method toString (line 680) | toString() {
    method create (line 686) | create(options) {
  class Registry (line 751) | class Registry {
    method constructor (line 752) | constructor(options = {}) {
    method container (line 819) | container(options) {
    method register (line 837) | register(fullName, factory, options = {}) {
    method unregister (line 861) | unregister(fullName) {
    method resolve (line 899) | resolve(fullName, options) {
    method describe (line 917) | describe(fullName) {
    method normalizeFullName (line 933) | normalizeFullName(fullName) {
    method normalize (line 949) | normalize(fullName) {
    method makeToString (line 959) | makeToString(factory, fullName) {
    method has (line 978) | has(fullName, options) {
    method optionsForType (line 1007) | optionsForType(type, options) {
    method getOptionsForType (line 1010) | getOptionsForType(type) {
    method options (line 1023) | options(fullName, options) {
    method getOptions (line 1027) | getOptions(fullName) {
    method getOption (line 1035) | getOption(fullName, optionName) {
    method typeInjection (line 1076) | typeInjection(type, property, fullName) {
    method injection (line 1118) | injection(fullName, property, injectionName) {
    method knownForType (line 1136) | knownForType(type) {
    method isValidFullName (line 1155) | isValidFullName(fullName) {
    method getInjections (line 1158) | getInjections(fullName) {
    method getTypeInjections (line 1168) | getTypeInjections(type) {
    method expandLocalLookup (line 1193) | expandLocalLookup(fullName, options) {
  function expandLocalLookup (line 1237) | function expandLocalLookup(registry, normalizedName, normalizedSource, n...
  function resolve (line 1251) | function resolve(registry, _normalizedName, options) {
  function has (line 1282) | function has(registry, fullName, source, namespace) {
  function privatize (line 1287) | function privatize([fullName]) {
  function checkGlobal (line 1312) | function checkGlobal(value) {
  function checkElementIdShadowing (line 1316) | function checkElementIdShadowing(value) {
  function getLookup (line 1334) | function getLookup() {
  function setLookup (line 1337) | function setLookup(value) {
  function getENV (line 1479) | function getENV() {
  method onerror (line 1499) | get onerror() {
  function getOnerror (line 1504) | function getOnerror() {
  function setOnerror (line 1508) | function setOnerror(handler) {
  function getDispatchOverride (line 1513) | function getDispatchOverride() {
  function setDispatchOverride (line 1516) | function setDispatchOverride(handler) {
  method canCatalogEntriesByType (line 1558) | canCatalogEntriesByType(type) {
  method catalogEntriesByType (line 1573) | catalogEntriesByType(type) {
  method init (line 1599) | init() {
  method getFilters (line 1655) | getFilters() {
  method watchModelTypes (line 1669) | watchModelTypes(typesAdded, typesUpdated) {
  method _nameToClass (line 1691) | _nameToClass(type) {
  method watchRecords (line 1718) | watchRecords(modelName, recordsAdded, recordsUpdated, recordsRemoved) {
  method willDestroy (line 1771) | willDestroy() {
  method detect (line 1784) | detect() {
  method columnsForType (line 1796) | columnsForType() {
  method observeModelType (line 1809) | observeModelType(modelName, typesUpdated) {
  method wrapModelType (line 1853) | wrapModelType(klass, name) {
  method getModelTypes (line 1873) | getModelTypes() {
  method _getObjectsOnNamespaces (line 1902) | _getObjectsOnNamespaces() {
  method getRecords (line 1931) | getRecords() {
  method wrapRecord (line 1944) | wrapRecord(record) {
  method getRecordColumnValues (line 1962) | getRecordColumnValues() {
  method getRecordKeywords (line 1972) | getRecordKeywords() {
  method getRecordFilterValues (line 1983) | getRecordFilterValues() {
  method getRecordColor (line 1995) | getRecordColor() {
  method observeRecord (line 2006) | observeRecord() {
  function template (line 2041) | function template(json) {
  class FactoryWrapper (line 2044) | class FactoryWrapper {
    method constructor (line 2045) | constructor(factory) {
    method create (line 2050) | create(injections) {
  function isHelperFactory (line 2062) | function isHelperFactory(helper) {
  function isSimpleHelper (line 2065) | function isSimpleHelper(helper) {
  method init (line 2109) | init() {
  method recompute (line 2136) | recompute() {
  class Wrapper (line 2141) | class Wrapper {
    method constructor (line 2142) | constructor(compute) {
    method create (line 2146) | create() {
  function helper (line 2175) | function helper(helperFn) {
  function toBool (line 2179) | function toBool(predicate) {
  class EmberPathReference (line 2205) | class EmberPathReference {
    method get (line 2206) | get(key) {
  class CachedReference$1 (line 2210) | class CachedReference$1 extends EmberPathReference {
    method constructor (line 2211) | constructor() {
    method value (line 2216) | value() {
  class RootReference (line 2225) | class RootReference extends _reference.ConstReference {
    method constructor (line 2226) | constructor(value) {
    method get (line 2230) | get(propertyKey) {
  method create (line 2241) | static create(tag, key, ref) {
  method constructor (line 2244) | constructor(tag, key, ref) {
  method value (line 2250) | value() {
  method validate (line 2253) | validate(ticket) {
  method didCompute (line 2261) | didCompute(parent) {
  class PropertyReference (line 2267) | class PropertyReference extends CachedReference$1 {
    method create (line 2268) | static create(parentReference, propertyKey) {
    method get (line 2275) | get(key) {
  class RootPropertyReference (line 2279) | class RootPropertyReference extends PropertyReference {
    method constructor (line 2280) | constructor(parentValue, propertyKey) {
    method compute (line 2293) | compute() {
    method [UPDATE] (line 2300) | [UPDATE](value) {
  class NestedPropertyReference (line 2304) | class NestedPropertyReference extends PropertyReference {
    method constructor (line 2305) | constructor(parentReference, propertyKey) {
    method compute (line 2319) | compute() {
    method [UPDATE] (line 2339) | [UPDATE](value) {
  class UpdatableReference (line 2344) | class UpdatableReference extends EmberPathReference {
    method constructor (line 2345) | constructor(value) {
    method value (line 2350) | value() {
    method update (line 2353) | update(value) {
  class ConditionalReference$1 (line 2361) | class ConditionalReference$1 extends _runtime.ConditionalReference {
    method create (line 2362) | static create(reference) {
    method constructor (line 2373) | constructor(reference) {
    method toBool (line 2378) | toBool(predicate) {
  class SimpleHelperReference (line 2388) | class SimpleHelperReference extends CachedReference$1 {
    method create (line 2389) | static create(helper$$1, args) {
    method constructor (line 2404) | constructor(helper$$1, args) {
    method compute (line 2410) | compute() {
  class ClassBasedHelperReference (line 2421) | class ClassBasedHelperReference extends CachedReference$1 {
    method create (line 2422) | static create(instance, args) {
    method constructor (line 2425) | constructor(instance, args) {
    method compute (line 2431) | compute() {
  class InternalHelperReference (line 2442) | class InternalHelperReference extends CachedReference$1 {
    method constructor (line 2443) | constructor(helper$$1, args) {
    method compute (line 2449) | compute() {
  class UnboundReference (line 2454) | class UnboundReference extends _reference.ConstReference {
    method create (line 2455) | static create(value) {
    method get (line 2458) | get(key) {
  class ReadonlyReference (line 2462) | class ReadonlyReference extends CachedReference$1 {
    method constructor (line 2463) | constructor(inner) {
    method tag (line 2467) | get tag() {
    method [INVOKE] (line 2470) | get [INVOKE]() {
    method compute (line 2473) | compute() {
    method get (line 2476) | get(key) {
  function referenceFromParts (line 2480) | function referenceFromParts(root, parts) {
  function valueToRef (line 2487) | function valueToRef(value, bound = true) {
  method init (line 3041) | init() {
  method rerender (line 3069) | rerender() {
  method [_metal.PROPERTY_DID_CHANGE] (line 3073) | [_metal.PROPERTY_DID_CHANGE](key) {
  method getAttr (line 3083) | getAttr(key) {
  method readDOMAttr (line 3113) | readDOMAttr(name) {
  method didReceiveAttrs (line 3187) | didReceiveAttrs() {}
  method didRender (line 3204) | didRender() {}
  method willRender (line 3219) | willRender() {}
  method didUpdateAttrs (line 3234) | didUpdateAttrs() {}
  method willUpdate (line 3249) | willUpdate() {}
  method didUpdate (line 3264) | didUpdate() {}
  method didInsertElement (line 3308) | didInsertElement() {
  method change (line 3312) | change() {
  function canSetTypeOfInput (line 3322) | function canSetTypeOfInput(type) {
  method get (line 3379) | get() {
  method set (line 3382) | set(_key, value) {
  method init (line 3807) | init() {
  method get (line 3822) | get(_key) {
  method set (line 3828) | set(_key, value) {
  method _isActive (line 3833) | _isActive(routerState) {
  method _invoke (line 3903) | _invoke(event) {
  method _generateTransition (line 3941) | _generateTransition(payload, qualifiedRouteName, models, queryParams, sh...
  method didReceiveAttrs (line 4042) | didReceiveAttrs() {
  class Element (line 4083) | class Element {
    method constructor (line 4084) | constructor(name) {
  class TemplateElement (line 4088) | class TemplateElement extends Element {}
  class EngineElement (line 4089) | class EngineElement extends Element {}
  method constructor (line 4092) | constructor() {
  method push (line 4095) | push(name) {
  method pushEngine (line 4098) | pushEngine(name) {
  method pop (line 4101) | pop() {
  method peek (line 4107) | peek() {
  method _currentTemplate (line 4116) | _currentTemplate() {
  method _currentEngine (line 4119) | _currentEngine() {
  method _getCurrentByType (line 4122) | _getCurrentByType(type) {
  class EachInReference (line 4243) | class EachInReference {
    method constructor (line 4244) | constructor(inner) {
    method value (line 4249) | value() {
    method get (line 4252) | get(key) {
  function isEachIn (line 4256) | function isEachIn(ref) {
  function eachIn (line 4259) | function eachIn(_vm, args) {
  function iterableFor (line 4264) | function iterableFor(ref, keyPath) {
  class BoundedIterator (line 4271) | class BoundedIterator {
    method constructor (line 4272) | constructor(length, keyFor) {
    method isEmpty (line 4277) | isEmpty() {
    method memoFor (line 4280) | memoFor(position) {
    method next (line 4283) | next() {
  class ArrayIterator (line 4295) | class ArrayIterator extends BoundedIterator {
    method constructor (line 4296) | constructor(array, length, keyFor) {
    method from (line 4300) | static from(array, keyFor) {
    method fromForEachable (line 4308) | static fromForEachable(object, keyFor) {
    method valueFor (line 4313) | valueFor(position) {
  class EmberArrayIterator (line 4317) | class EmberArrayIterator extends BoundedIterator {
    method constructor (line 4318) | constructor(array, length, keyFor) {
    method from (line 4322) | static from(array, keyFor) {
    method valueFor (line 4330) | valueFor(position) {
  class ObjectIterator (line 4334) | class ObjectIterator extends BoundedIterator {
    method constructor (line 4335) | constructor(keys, values, length, keyFor) {
    method fromIndexable (line 4340) | static fromIndexable(obj, keyFor) {
    method fromForEachable (line 4353) | static fromForEachable(obj, keyFor) {
    method valueFor (line 4374) | valueFor(position) {
    method memoFor (line 4377) | memoFor(position) {
  class NativeIterator (line 4381) | class NativeIterator {
    method constructor (line 4382) | constructor(iterable, result, keyFor) {
    method from (line 4388) | static from(iterable, keyFor) {
    method isEmpty (line 4400) | isEmpty() {
    method next (line 4403) | next() {
  class ArrayLikeNativeIterator (line 4416) | class ArrayLikeNativeIterator extends NativeIterator {
    method valueFor (line 4417) | valueFor(result) {
    method memoFor (line 4420) | memoFor(_result, position) {
  class MapLikeNativeIterator (line 4424) | class MapLikeNativeIterator extends NativeIterator {
    method valueFor (line 4425) | valueFor(result) {
    method memoFor (line 4428) | memoFor(result) {
  method isEmpty (line 4433) | isEmpty() {
  method next (line 4436) | next() {
  class EachInIterable (line 4442) | class EachInIterable {
    method constructor (line 4443) | constructor(ref, keyPath) {
    method iterate (line 4449) | iterate() {
    method valueReferenceFor (line 4472) | valueReferenceFor(item) {
    method updateValueReference (line 4475) | updateValueReference(ref, item) {
    method memoReferenceFor (line 4478) | memoReferenceFor(item) {
    method updateMemoReference (line 4481) | updateMemoReference(ref, item) {
    method keyFor (line 4484) | keyFor(hasUniqueKeys = false) {
  class EachIterable (line 4500) | class EachIterable {
    method constructor (line 4501) | constructor(ref, keyPath) {
    method iterate (line 4507) | iterate() {
    method valueReferenceFor (line 4527) | valueReferenceFor(item) {
    method updateValueReference (line 4530) | updateValueReference(ref, item) {
    method memoReferenceFor (line 4533) | memoReferenceFor(item) {
    method updateMemoReference (line 4536) | updateMemoReference(ref, item) {
    method keyFor (line 4539) | keyFor() {
  function hasForEach (line 4553) | function hasForEach(value) {
  function isNativeIterable (line 4556) | function isNativeIterable(value) {
  function isIndexable (line 4559) | function isIndexable(value) {
  function Index (line 4563) | function Index(_value, _memo, position) {
  function ObjectKey (line 4567) | function ObjectKey(_value, memo) {
  function MapKey (line 4571) | function MapKey(_value, memo) {
  function Identity (line 4574) | function Identity(value) {
  function KeyPath (line 4584) | function KeyPath(keyPath) {
  function Unique (line 4587) | function Unique(func) {
  class SafeString (line 4605) | class SafeString {
    method constructor (line 4606) | constructor(string) {
    method toString (line 4609) | toString() {
    method toHTML (line 4612) | toHTML() {
  function escapeChar (line 4627) | function escapeChar(chr) {
  function escapeExpression (line 4630) | function escapeExpression(string) {
  function htmlSafe (line 4667) | function htmlSafe(str) {
  function isHTMLSafe (line 4694) | function isHTMLSafe(str) {
  function installProtocolForURL (line 4701) | function installProtocolForURL(environment) {
  function browserProtocolForURL (line 4727) | function browserProtocolForURL(url) {
  function nodeProtocolForURL (line 4734) | function nodeProtocolForURL(url) {
  class Environment$1 (line 4742) | class Environment$1 extends _runtime.Environment {
    method constructor (line 4743) | constructor(injections) {
    method create (line 4755) | static create(options) {
    method protocolForURL (line 4760) | protocolForURL(s) {
    method lookupComponent (line 4763) | lookupComponent(name, meta) {
    method toConditionalReference (line 4766) | toConditionalReference(reference) {
    method iterableFor (line 4769) | iterableFor(ref, key) {
    method scheduleInstallModifier (line 4772) | scheduleInstallModifier(modifier, manager) {
    method scheduleUpdateModifier (line 4777) | scheduleUpdateModifier(modifier, manager) {
    method didDestroy (line 4782) | didDestroy(destroyable) {
    method begin (line 4785) | begin() {
    method commit (line 4789) | commit() {
  class StyleAttributeManager (line 4806) | class StyleAttributeManager extends _runtime.SimpleDynamicAttribute {
    method set (line 4807) | set(dom, value, env) {
    method update (line 4817) | update(value, env) {
  class AbstractManager (line 4839) | class AbstractManager {
    method constructor (line 4840) | constructor() {
    method prepareArgs (line 4843) | prepareArgs(_state, _args) {
    method didCreateElement (line 4846) | didCreateElement(_component, _element, _operations) {}
    method didRenderLayout (line 4852) | didRenderLayout(_component, _bounds) {
    method didCreate (line 4855) | didCreate(_bucket) {}
    method update (line 4861) | update(_bucket, _dynamicScope) {}
    method didUpdateLayout (line 4867) | didUpdateLayout(_bucket, _bounds) {
    method didUpdate (line 4870) | didUpdate(_bucket) {
  function instrumentationPayload (line 4885) | function instrumentationPayload(def) {
  class OutletComponentManager (line 4900) | class OutletComponentManager extends AbstractManager {
    method create (line 4901) | create(environment, definition, _args, dynamicScope) {
    method layoutFor (line 4913) | layoutFor(_state, _component, _env) {
    method getLayout (line 4916) | getLayout({ template }, _resolver) {
    method getCapabilities (line 4924) | getCapabilities() {
    method getSelf (line 4927) | getSelf({ self }) {
    method getTag (line 4930) | getTag() {
    method didRenderLayout (line 4934) | didRenderLayout(state) {
    method getDestructor (line 4940) | getDestructor() {
  class OutletComponentDefinition (line 4945) | class OutletComponentDefinition {
    method constructor (line 4946) | constructor(state, manager = OUTLET_MANAGER) {
  function createRootOutlet (line 4951) | function createRootOutlet(outletView) {
  function NOOP (line 4987) | function NOOP() {}
  class ComponentStateBucket (line 4997) | class ComponentStateBucket {
    method constructor (line 4998) | constructor(environment, component, args, finalizer, hasWrappedElement) {
    method destroy (line 5008) | destroy() {
    method finalize (line 5016) | finalize() {
  function referenceForKey (line 5023) | function referenceForKey(component, key) {
  function referenceForParts (line 5026) | function referenceForParts(component, parts) {
  function wrapComponentClassAttribute (line 5038) | function wrapComponentClassAttribute(hash) {
  method parse (line 5058) | parse(microsyntax) {
  method install (line 5072) | install(_element, component, parsed, operations) {
  class StyleBindingReference (line 5097) | class StyleBindingReference extends _reference.CachedReference {
    method constructor (line 5098) | constructor(inner, isVisible) {
    method compute (line 5104) | compute() {
  method install (line 5118) | install(_element, component, operations) {
  method mapStyleValue (line 5125) | mapStyleValue(isVisible) {
  method install (line 5130) | install(_element, component, microsyntax, operations) {
  class SimpleClassNameBindingReference (line 5153) | class SimpleClassNameBindingReference extends _reference.CachedReference {
    method constructor (line 5154) | constructor(inner, path) {
    method compute (line 5163) | compute() {
  class ColonClassNameBindingReference (line 5175) | class ColonClassNameBindingReference extends _reference.CachedReference {
    method constructor (line 5176) | constructor(inner, truthy = null, falsy = null) {
    method compute (line 5183) | compute() {
  function processComponentArgs (line 5192) | function processComponentArgs(namedArgs) {
  class MutableCell (line 5214) | class MutableCell {
    method constructor (line 5215) | constructor(ref, value) {
    method update (line 5220) | update(val) {
  function aliasIdToElementId (line 5225) | function aliasIdToElementId(args, props) {
  function isTemplateFactory (line 5233) | function isTemplateFactory(template) {
  function applyAttributeBindings (line 5239) | function applyAttributeBindings(element, attributeBindings, component, o...
  class CurlyComponentManager (line 5261) | class CurlyComponentManager extends AbstractManager {
    method getLayout (line 5262) | getLayout(state, _resolver) {
    method templateFor (line 5269) | templateFor(component, resolver) {
    method getDynamicLayout (line 5290) | getDynamicLayout({ component }, resolver) {
    method getTagName (line 5298) | getTagName(state) {
    method getCapabilities (line 5305) | getCapabilities(state) {
    method prepareArgs (line 5308) | prepareArgs(state, args) {
    method create (line 5346) | create(environment, state, args, dynamicScope, callerSelfRef, hasBlock) {
    method getSelf (line 5413) | getSelf({ component }) {
    method didCreateElement (line 5416) | didCreateElement({ component, classRef, environment }, element, operat...
    method didRenderLayout (line 5449) | didRenderLayout(bucket, bounds) {
    method getTag (line 5456) | getTag({ args, component }) {
    method didCreate (line 5459) | didCreate({ component, environment }) {
    method update (line 5466) | update(bucket) {
    method didUpdateLayout (line 5486) | didUpdateLayout(bucket) {
    method didUpdate (line 5492) | didUpdate({ component, environment }) {
    method getDestructor (line 5498) | getDestructor(stateBucket) {
  function processComponentInitializationAssertions (line 5502) | function processComponentInitializationAssertions(component, props) {
  function initialRenderInstrumentDetails (line 5539) | function initialRenderInstrumentDetails(component) {
  function rerenderInstrumentDetails (line 5542) | function rerenderInstrumentDetails(component) {
  class CurlyComponentDefinition (line 5558) | class CurlyComponentDefinition {
    method constructor (line 5560) | constructor(name, ComponentClass, handle, template, args) {
  class RootComponentManager (line 5581) | class RootComponentManager extends CurlyComponentManager {
    method constructor (line 5582) | constructor(component) {
    method getLayout (line 5586) | getLayout(_state, resolver) {
    method create (line 5594) | create(environment, _state, _args, dynamicScope) {
  class RootComponentDefinition (line 5632) | class RootComponentDefinition {
    method constructor (line 5633) | constructor(component) {
    method getTag (line 5645) | getTag({ component }) {
  class DynamicScope (line 5650) | class DynamicScope {
    method constructor (line 5651) | constructor(view, outletState) {
    method child (line 5655) | child() {
    method get (line 5658) | get(key) {
    method set (line 5664) | set(key, value) {
  class RootState (line 5672) | class RootState {
    method constructor (line 5673) | constructor(root, env, template, self, parentElement, dynamicScope, bu...
    method isFor (line 5698) | isFor(possibleRoot) {
    method destroy (line 5701) | destroy() {
  function _resetRenderers (line 5732) | function _resetRenderers() {
  function register (line 5736) | function register(renderer) {
  function deregister (line 5741) | function deregister(renderer) {
  function loopBegin (line 5747) | function loopBegin() {
  function K (line 5752) | function K() {
  function renderSettled (line 5765) | function renderSettled() {
  function resolveRenderPromise (line 5777) | function resolveRenderPromise() {
  function loopEnd (line 5785) | function loopEnd() {
  class Renderer (line 5803) | class Renderer {
    method constructor (line 5804) | constructor(env, rootTemplate, _viewRegistry = _views.fallbackViewRegi...
    method appendOutletView (line 5817) | appendOutletView(view, target) {
    method appendTo (line 5821) | appendTo(view, target) {
    method _appendDefinition (line 5825) | _appendDefinition(root, definition, target) {
    method rerender (line 5831) | rerender() {
    method register (line 5834) | register(view) {
    method unregister (line 5840) | unregister(view) {
    method remove (line 5843) | remove(view) {
    method cleanupRootFor (line 5854) | cleanupRootFor(view) {
    method destroy (line 5871) | destroy() {
    method getBounds (line 5878) | getBounds(view) {
    method createElement (line 5885) | createElement(tagName) {
    method _renderRoot (line 5888) | _renderRoot(root) {
    method _renderRoots (line 5896) | _renderRoots() {
    method _renderRootsTransaction (line 5944) | _renderRootsTransaction() {
    method _clearAllRoots (line 5967) | _clearAllRoots() {
    method _scheduleRevalidate (line 5981) | _scheduleRevalidate() {
    method _isValid (line 5984) | _isValid() {
    method _revalidate (line 5987) | _revalidate() {
  class InertRenderer (line 5994) | class InertRenderer extends Renderer {
    method create (line 5995) | static create({ env, rootTemplate, _viewRegistry, builder }) {
    method getElement (line 5998) | getElement(_view) {
  class InteractiveRenderer (line 6002) | class InteractiveRenderer extends Renderer {
    method create (line 6003) | static create({ env, rootTemplate, _viewRegistry, builder }) {
    method getElement (line 6006) | getElement(view) {
  function setTemplates (line 6012) | function setTemplates(templates) {
  function getTemplates (line 6015) | function getTemplates() {
  function getTemplate (line 6018) | function getTemplate(name) {
  function hasTemplate (line 6023) | function hasTemplate(name) {
  function setTemplate (line 6026) | function setTemplate(name, template) {
  class CompileTimeLookup (line 6071) | class CompileTimeLookup {
    method constructor (line 6072) | constructor(resolver) {
    method getCapabilities (line 6075) | getCapabilities(handle) {
    method getLayout (line 6080) | getLayout(handle) {
    method lookupHelper (line 6095) | lookupHelper(name, referrer) {
    method lookupModifier (line 6098) | lookupModifier(name, referrer) {
    method lookupComponentDefinition (line 6101) | lookupComponentDefinition(name, referrer) {
    method lookupPartial (line 6104) | lookupPartial(name, referrer) {
  function setManager (line 6111) | function setManager(factory, obj) {
  function getManager (line 6115) | function getManager(obj) {
  function valueForCapturedArgs (line 6125) | function valueForCapturedArgs(args) {
  function capabilities (line 6144) | function capabilities(managerAPI, options = {}) {
  function hasAsyncLifeCycleCallbacks (line 6152) | function hasAsyncLifeCycleCallbacks(delegate) {
  function hasDestructors (line 6155) | function hasDestructors(delegate) {
  class CustomComponentManager (line 6183) | class CustomComponentManager extends AbstractManager {
    method create (line 6184) | create(_env, definition, args) {
    method update (line 6191) | update({ delegate, component, args }) {
    method didCreate (line 6194) | didCreate({ delegate, component }) {
    method didUpdate (line 6199) | didUpdate({ delegate, component }) {
    method getContext (line 6204) | getContext({ delegate, component }) {
    method getSelf (line 6207) | getSelf({ delegate, component }) {
    method getDestructor (line 6211) | getDestructor(state) {
    method getCapabilities (line 6218) | getCapabilities() {
    method getTag (line 6221) | getTag({ args }) {
    method didRenderLayout (line 6224) | didRenderLayout() {}
    method getLayout (line 6225) | getLayout(state) {
  class CustomComponentState (line 6236) | class CustomComponentState {
    method constructor (line 6237) | constructor(delegate, component, args) {
    method destroy (line 6242) | destroy() {
  class CustomManagerDefinition (line 6249) | class CustomManagerDefinition {
    method constructor (line 6250) | constructor(name, ComponentClass, delegate, template) {
  class TemplateOnlyComponentManager (line 6281) | class TemplateOnlyComponentManager extends AbstractManager {
    method getLayout (line 6282) | getLayout(template) {
    method getCapabilities (line 6289) | getCapabilities() {
    method create (line 6292) | create() {
    method getSelf (line 6295) | getSelf() {
    method getTag (line 6298) | getTag() {
    method getDestructor (line 6301) | getDestructor() {
  class TemplateOnlyComponentDefinition (line 6306) | class TemplateOnlyComponentDefinition {
    method constructor (line 6307) | constructor(state) {
  class ComponentAssertionReference (line 6313) | class ComponentAssertionReference {
    method constructor (line 6314) | constructor(component, message) {
    method value (line 6319) | value() {
    method get (line 6326) | get(property) {
  function classHelper (line 6338) | function classHelper({ positional }) {
  function classHelper$1 (line 6356) | function classHelper$1(_vm, args) {
  function htmlSafe$1 (line 6360) | function htmlSafe$1({ positional }) {
  function htmlSafeHelper (line 6364) | function htmlSafeHelper(_vm, args) {
  function inputTypeHelper (line 6368) | function inputTypeHelper({ positional }) {
  function inputTypeHelper$1 (line 6375) | function inputTypeHelper$1(_vm, args) {
  function normalizeClass (line 6379) | function normalizeClass({ positional }) {
  function normalizeClassHelper (line 6391) | function normalizeClassHelper(_vm, args) {
  function action (line 6652) | function action(_vm, args) {
  function NOOP$1 (line 6675) | function NOOP$1(args) {
  function makeArgsProcessor (line 6678) | function makeArgsProcessor(valuePathRef, actionArgsRef) {
  function makeDynamicClosureAction (line 6703) | function makeDynamicClosureAction(context, targetRef, actionRef, process...
  function makeClosureAction (line 6712) | function makeClosureAction(context, target, action, processArgs, debugKe...
  function array (line 6773) | function array(_vm, args) {
  function concat (line 6805) | function concat({ positional }) {
  function concat$1 (line 6808) | function concat$1(_vm, args) {
  function get$1 (line 6858) | function get$1(_vm, args) {
  function referenceFromPath (line 6861) | function referenceFromPath(source, path) {
  class GetHelperReference (line 6872) | class GetHelperReference extends CachedReference$1 {
    method create (line 6873) | static create(sourceReference, pathReference) {
    method constructor (line 6881) | constructor(sourceReference, pathReference) {
    method compute (line 6890) | compute() {
    method [UPDATE] (line 6901) | [UPDATE](value) {
  function hash (line 6947) | function hash(_vm, args) {
  class ConditionalHelperReference (line 6954) | class ConditionalHelperReference extends CachedReference$1 {
    method create (line 6955) | static create(_condRef, truthyRef, falsyRef) {
    method constructor (line 6963) | constructor(cond, truthy, falsy) {
    method compute (line 6971) | compute() {
  function inlineIf (line 7059) | function inlineIf(_vm, { positional }) {
  function inlineUnless (line 7084) | function inlineUnless(_vm, { positional }) {
  function log (line 7106) | function log({ positional }) {
  function log$1 (line 7111) | function log$1(_vm, args) {
  function isMut (line 7189) | function isMut(ref) {
  function unMut (line 7192) | function unMut(ref) {
  function mut (line 7195) | function mut(_vm, args) {
  function queryParams (line 7240) | function queryParams({ positional, named }) {
  function queryParams$1 (line 7246) | function queryParams$1(_vm, args) {
  function readonly (line 7348) | function readonly(_vm, args) {
  function unbound (line 7383) | function unbound(_vm, args) {
  function isAllowedEvent (line 7391) | function isAllowedEvent(event, allowedKeys) {
  method registerAction (line 7413) | registerAction(actionState) {
  method unregisterAction (line 7418) | unregisterAction(actionState) {
  class ActionState (line 7423) | class ActionState {
    method constructor (line 7424) | constructor(element, actionId, actionName, actionArgs, namedArgs, posi...
    method getEventName (line 7436) | getEventName() {
    method getActionArgs (line 7439) | getActionArgs() {
    method getTarget (line 7446) | getTarget() {
    method handler (line 7456) | handler(event) {
    method destroy (line 7506) | destroy() {
  class ActionModifierManager (line 7511) | class ActionModifierManager {
    method create (line 7512) | create(element, _state, args, _dynamicScope, dom) {
    method install (line 7537) | install(actionState) {
    method update (line 7543) | update(actionState) {
    method getTag (line 7551) | getTag(actionState) {
    method getDestructor (line 7554) | getDestructor(modifier) {
  function capabilities$1 (line 7560) | function capabilities$1(_managerAPI, _optionalFeatures) {
  class CustomModifierDefinition (line 7563) | class CustomModifierDefinition {
    method constructor (line 7564) | constructor(name, ModifierClass, delegate) {
  class CustomModifierState (line 7576) | class CustomModifierState {
    method constructor (line 7577) | constructor(element, delegate, modifier, args) {
    method destroy (line 7583) | destroy() {
  class CustomModifierManager (line 7610) | class CustomModifierManager {
    method create (line 7611) | create(element, definition, args) {
    method getTag (line 7617) | getTag({ args }) {
    method install (line 7620) | install(state) {
    method update (line 7625) | update(state) {
    method getDestructor (line 7630) | getDestructor(state) {
  function hashToArgs (line 7636) | function hashToArgs(hash) {
  function textAreaMacro (line 7642) | function textAreaMacro(_name, params, hash, builder) {
  function buildSyntax (line 7649) | function buildSyntax(type, params, hash, builder) {
  function inputMacro (line 7789) | function inputMacro(_name, params, hash, builder) {
  function blockLetMacro (line 7855) | function blockLetMacro(params, _hash, template, _inverse, builder) {
  class MountManager (line 7879) | class MountManager extends AbstractManager {
    method getDynamicLayout (line 7880) | getDynamicLayout(state, _) {
    method getCapabilities (line 7888) | getCapabilities() {
    method create (line 7891) | create(environment, state) {
    method getSelf (line 7930) | getSelf({ self }) {
    method getTag (line 7933) | getTag(state) {
    method getDestructor (line 7936) | getDestructor({ engine }) {
    method didRenderLayout (line 7939) | didRenderLayout() {
    method update (line 7944) | update(bucket) {
  class MountDefinition (line 7956) | class MountDefinition {
    method constructor (line 7957) | constructor(name, modelRef) {
  function mountHelper (line 7963) | function mountHelper(vm, args) {
  function mountMacro (line 8010) | function mountMacro(_name, params, hash, builder) {
  class DynamicEngineReference (line 8020) | class DynamicEngineReference {
    method constructor (line 8021) | constructor(nameRef, env, modelRef) {
    method value (line 8029) | value() {
    method get (line 8052) | get() {
  class RootOutletReference (line 8060) | class RootOutletReference {
    method constructor (line 8061) | constructor(outletState) {
    method get (line 8065) | get(key) {
    method value (line 8068) | value() {
    method update (line 8071) | update(state) {
  class OutletReference (line 8079) | class OutletReference {
    method constructor (line 8080) | constructor(parentStateRef, outletNameRef) {
    method value (line 8085) | value() {
    method get (line 8090) | get(key) {
  class PathReference (line 8098) | class PathReference {
    method constructor (line 8099) | constructor(parent, key) {
    method get (line 8104) | get(key) {
    method value (line 8107) | value() {
  function outletHelper (line 8161) | function outletHelper(vm, args) {
  function outletMacro (line 8171) | function outletMacro(_name, params, hash, builder) {
  class OutletComponentReference (line 8176) | class OutletComponentReference {
    method constructor (line 8177) | constructor(outletRef) {
    method value (line 8184) | value() {
    method get (line 8196) | get(_key) {
  function stateFor (line 8200) | function stateFor(ref) {
  function validate (line 8215) | function validate(state, lastState) {
  function refineInlineSyntax (line 8225) | function refineInlineSyntax(name, params, hash, builder) {
  function refineBlockSyntax (line 8238) | function refineBlockSyntax(name, params, hash, template, inverse, builde...
  function registerMacros (line 8269) | function registerMacros(macro) {
  function populateMacros (line 8272) | function populateMacros(macros) {
  function setComponentManager (line 8288) | function setComponentManager(stringOrFunction, obj) {
  function getComponentManager (line 8299) | function getComponentManager(obj) {
  function setModifierManager (line 8306) | function setModifierManager(factory, obj) {
  function getModifierManager (line 8309) | function getModifierManager(obj) {
  function instrumentationPayload$1 (line 8316) | function instrumentationPayload$1(name) {
  function makeOptions (line 8319) | function makeOptions(moduleName, namespace) {
  class RuntimeResolver (line 8351) | class RuntimeResolver {
    method constructor (line 8352) | constructor() {
    method lookupComponentDefinition (line 8374) | lookupComponentDefinition(name, meta) {
    method lookupComponentHandle (line 8386) | lookupComponentHandle(name, meta) {
    method resolve (line 8397) | resolve(handle) {
    method lookupHelper (line 8404) | lookupHelper(name, meta) {
    method lookupModifier (line 8419) | lookupModifier(name, meta) {
    method lookupPartial (line 8425) | lookupPartial(name, meta) {
    method createTemplate (line 8435) | createTemplate(factory, owner) {
    method handle (line 8455) | handle(obj) {
    method _lookupHelper (line 8466) | _lookupHelper(_name, meta) {
    method _lookupPartial (line 8493) | _lookupPartial(name, meta) {
    method _lookupModifier (line 8501) | _lookupModifier(name, meta) {
    method _parseNameForNamespace (line 8514) | _parseNameForNamespace(_name) {
    method _lookupComponentDefinition (line 8524) | _lookupComponentDefinition(_name, meta) {
    method _lookupComponentManager (line 8564) | _lookupComponentManager(owner, managerId) {
  method create (line 8576) | create() {
  class OutletView (line 8587) | class OutletView {
    method constructor (line 8588) | constructor(_environment, renderer, owner, template) {
    method extend (line 8612) | static extend(injections) {
    method reopenClass (line 8623) | static reopenClass(injections) {
    method create (line 8626) | static create(options) {
    method appendTo (line 8631) | appendTo(selector) {
    method rerender (line 8640) | rerender() {
    method setOutletState (line 8643) | setOutletState(state) {
    method destroy (line 8646) | destroy() {
  function setupApplicationRegistry (line 8651) | function setupApplicationRegistry(registry) {
  function setupEngineRegistry (line 8691) | function setupEngineRegistry(registry) {
  class Meta (line 8928) | class Meta {
    method constructor (line 8929) | constructor(obj) {
    method parent (line 8954) | get parent() {
    method setInitializing (line 8962) | setInitializing() {
    method unsetInitializing (line 8965) | unsetInitializing() {
    method isInitializing (line 8968) | isInitializing() {
    method isPrototypeMeta (line 8971) | isPrototypeMeta(obj) {
    method destroy (line 8974) | destroy() {
    method isSourceDestroying (line 8985) | isSourceDestroying() {
    method setSourceDestroying (line 8988) | setSourceDestroying() {
    method isSourceDestroyed (line 8991) | isSourceDestroyed() {
    method setSourceDestroyed (line 8994) | setSourceDestroyed() {
    method isMetaDestroyed (line 8997) | isMetaDestroyed() {
    method setMetaDestroyed (line 9000) | setMetaDestroyed() {
    method _hasFlag (line 9003) | _hasFlag(flag) {
    method _getOrCreateOwnMap (line 9006) | _getOrCreateOwnMap(key) {
    method _getOrCreateOwnSet (line 9009) | _getOrCreateOwnSet(key) {
    method _findInherited1 (line 9012) | _findInherited1(key) {
    method _findInherited2 (line 9022) | _findInherited2(key, subkey) {
    method _findInherited3 (line 9035) | _findInherited3(key, subkey, subsubkey) {
    method _hasInInheritedSet (line 9051) | _hasInInheritedSet(key, value) {
    method writeDeps (line 9064) | writeDeps(subkey, itemkey, count) {
    method peekDeps (line 9074) | peekDeps(subkey, itemkey) {
    method hasDeps (line 9078) | hasDeps(subkey) {
    method forEachInDeps (line 9082) | forEachInDeps(subkey, fn) {
    method writableTags (line 9111) | writableTags() {
    method readableTags (line 9114) | readableTags() {
    method writableTag (line 9117) | writableTag(create) {
    method readableTag (line 9126) | readableTag() {
    method writableChainWatchers (line 9129) | writableChainWatchers(create) {
    method readableChainWatchers (line 9138) | readableChainWatchers() {
    method writableChains (line 9141) | writableChains(create) {
    method readableChains (line 9155) | readableChains() {
    method writeWatching (line 9158) | writeWatching(subkey, value) {
    method peekWatching (line 9164) | peekWatching(subkey) {
    method addMixin (line 9168) | addMixin(mixin) {
    method hasMixin (line 9174) | hasMixin(mixin) {
    method forEachMixins (line 9177) | forEachMixins(fn) {
    method writeDescriptors (line 9195) | writeDescriptors(subkey, value) {
    method peekDescriptors (line 9201) | peekDescriptors(subkey) {
    method removeDescriptors (line 9205) | removeDescriptors(subkey) {
    method forEachDescriptors (line 9208) | forEachDescriptors(fn) {
    method addToListeners (line 9228) | addToListeners(eventName, target, method, once) {
    method removeFromListeners (line 9234) | removeFromListeners(eventName, target, method) {
    method removeAllListeners (line 9240) | removeAllListeners(event) {
    method pushListener (line 9272) | pushListener(event, target, method, kind) {
    method writableListeners (line 9318) | writableListeners() {
    method flattenedListeners (line 9348) | flattenedListeners() {
    method matchingListeners (line 9393) | matchingListeners(eventName) {
  function setMeta (line 9458) | function setMeta(obj, meta) {
  function peekMeta (line 9468) | function peekMeta(obj) {
  function deleteMeta (line 9508) | function deleteMeta(obj) {
  function descriptorFor (line 9568) | function descriptorFor(obj, keyName, _meta) {
  function isDescriptor (line 9586) | function isDescriptor(possibleDesc) {
  function indexOfListener (line 9592) | function indexOfListener(listeners, event, target, method) {
  function getCacheFor (line 9625) | function getCacheFor(obj) {
  function getCachedValueFor (line 9636) | function getCachedValueFor(obj, key) {
  function peekCacheFor (line 9659) | function peekCacheFor(obj) {
  function isPath (line 9664) | function isPath(path) {
  function changeEvent (line 9669) | function changeEvent(keyName) {
  function addListener (line 9706) | function addListener(obj, eventName, target, method, once) {
  function removeListener (line 9729) | function removeListener(obj, eventName, target, method) {
  function sendEvent (line 9758) | function sendEvent(obj, eventName, params, actions, _meta) {
  function hasListeners (line 9795) | function hasListeners(obj, eventName) {
  function on (line 9831) | function on(...args) {
  class ObserverSet (line 9856) | class ObserverSet {
    method constructor (line 9857) | constructor() {
    method add (line 9861) | add(object, key, event) {
    method flush (line 9872) | flush() {
  function setHasViews (line 9890) | function setHasViews(fn) {
  function makeTag (line 9893) | function makeTag() {
  function tagForProperty (line 9896) | function tagForProperty(object, propertyKey, _meta) {
  function tagFor (line 9916) | function tagFor(object, _meta) {
  function markObjectAsDirty (line 9938) | function markObjectAsDirty(obj, propertyKey, meta$$1) {
  function ensureRunloop (line 9956) | function ensureRunloop() {
  class TransactionRunner (line 9974) | class TransactionRunner {
    method constructor (line 9975) | constructor() {
    method runInTransaction (line 9985) | runInTransaction(context$$1, methodName) {
    method didRender (line 9994) | didRender(object, key, reference) {
    method assertNotRendered (line 10007) | assertNotRendered(object, key) {
    method hasRendered (line 10031) | hasRendered(object, key) {
    method before (line 10040) | before(context$$1) {
    method after (line 10047) | after() {
    method createMap (line 10055) | createMap(object) {
    method getOrCreateMap (line 10060) | getOrCreateMap(object) {
    method setKey (line 10067) | setKey(object, key, value) {
    method getKey (line 10071) | getKey(object, key) {
    method clearObjectMap (line 10077) | clearObjectMap() {
  function notifyPropertyChange (line 10117) | function notifyPropertyChange(obj, keyName, _meta) {
  function dependentKeysDidChange (line 10148) | function dependentKeysDidChange(obj, depKey, meta$$1) {
  function iterDeps (line 10163) | function iterDeps(method, obj, depKey, seen, meta$$1) {
  function chainsDidChange (line 10181) | function chainsDidChange(_obj, keyName, meta$$1) {
  function overrideChains (line 10187) | function overrideChains(_obj, keyName, meta$$1) {
  function beginPropertyChanges (line 10198) | function beginPropertyChanges() {
  function endPropertyChanges (line 10205) | function endPropertyChanges() {
  function changeProperties (line 10226) | function changeProperties(callback) {
  function notifyObservers (line 10234) | function notifyObservers(obj, keyName, meta$$1) {
  class Descriptor (line 10259) | class Descriptor {
    method constructor (line 10260) | constructor() {
    method setup (line 10265) | setup(obj, keyName, meta$$1) {
    method teardown (line 10273) | teardown(_obj, keyName, meta$$1) {
  function MANDATORY_SETTER_FUNCTION (line 10280) | function MANDATORY_SETTER_FUNCTION(name) {
  function DEFAULT_GETTER_FUNCTION (line 10291) | function DEFAULT_GETTER_FUNCTION(name) {
  function INHERITING_GETTER_FUNCTION (line 10299) | function INHERITING_GETTER_FUNCTION(name) {
  function DESCRIPTOR_GETTER_FUNCTION (line 10317) | function DESCRIPTOR_GETTER_FUNCTION(name, descriptor) {
  function defineProperty (line 10370) | function defineProperty(obj, keyName, desc, data, meta$$1) {
  function watchKey (line 10433) | function watchKey(obj, keyName, _meta) {
  function unwatchKey (line 10486) | function unwatchKey(obj, keyName, _meta) {
  function eachProxyArrayWillChange (line 10538) | function eachProxyArrayWillChange(array, idx, removedCnt, addedCnt) {
  function eachProxyArrayDidChange (line 10544) | function eachProxyArrayDidChange(array, idx, removedCnt, addedCnt) {
  function arrayContentWillChange (line 10551) | function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {
  function arrayContentDidChange (line 10568) | function arrayContentDidChange(array, startIdx, removeAmt, addAmt) {
  class Tracker (line 10615) | class Tracker {
    method constructor (line 10616) | constructor() {
    method add (line 10620) | add(tag) {
    method size (line 10624) | get size() {
    method combine (line 10627) | combine() {
  function tracked (line 10639) | function tracked(...dependencies) {
  function getCurrentTracker (line 10663) | function getCurrentTracker() {
  function setCurrentTracker (line 10666) | function setCurrentTracker(tracker = new Tracker()) {
  function descriptorForAccessor (line 10669) | function descriptorForAccessor(key, descriptor) {
  function descriptorForDataProperty (line 10710) | function descriptorForDataProperty(key, descriptor) {
  function get (line 10785) | function get(obj, keyName) {
  function _getPath (line 10824) | function _getPath(root, path) {
  function getWithDefault (line 10853) | function getWithDefault(root, key, defaultValue) {
  function objectAt (line 10862) | function objectAt(array, index) {
  function replace (line 10869) | function replace(array, start, deleteCount, items = EMPTY_ARRAY) {
  function replaceInNativeArray (line 10879) | function replaceInNativeArray(array, start, deleteCount, items) {
  function arrayObserversHelper (line 10892) | function arrayObserversHelper(obj, target, opts, operation, notify) {
  function addArrayObserver (line 10903) | function addArrayObserver(array, target, opts) {
  function removeArrayObserver (line 10906) | function removeArrayObserver(array, target, opts) {
  function addObserver (line 10923) | function addObserver(obj, path, target, method) {
  function removeObserver (line 10937) | function removeObserver(obj, path, target, method) {
  function eachProxyFor (line 10942) | function eachProxyFor(array) {
  class EachProxy (line 10950) | class EachProxy {
    method constructor (line 10951) | constructor(content) {
    method arrayWillChange (line 10959) | arrayWillChange(content, idx, removedCnt /*, addedCnt */) {
    method arrayDidChange (line 10972) | arrayDidChange(content, idx, _removedCnt, addedCnt) {
    method willWatchProperty (line 10989) | willWatchProperty(property) {
    method didUnwatchProperty (line 10992) | didUnwatchProperty(property) {
    method beginObservingContentKey (line 10998) | beginObservingContentKey(keyName) {
    method stopObservingContentKey (line 11012) | stopObservingContentKey(keyName) {
    method contentKeyDidChange (line 11020) | contentKeyDidChange(_obj, keyName) {
  function addObserverForContentKey (line 11024) | function addObserverForContentKey(content, keyName, proxy, idx, loc) {
  function removeObserverForContentKey (line 11034) | function removeObserverForContentKey(content, keyName, proxy, idx, loc) {
  function isObject (line 11043) | function isObject(obj) {
  function isVolatile (line 11046) | function isVolatile(obj, keyName, meta$$1) {
  class ChainWatchers (line 11050) | class ChainWatchers {
    method constructor (line 11051) | constructor() {
    method add (line 11057) | add(key, node) {
    method remove (line 11065) | remove(key, node) {
    method has (line 11076) | has(key, node) {
    method revalidateAll (line 11087) | revalidateAll() {
    method revalidate (line 11092) | revalidate(key) {
    method notify (line 11100) | notify(key, revalidate, callback) {
  function makeChainWatcher (line 11123) | function makeChainWatcher() {
  function makeChainNode (line 11126) | function makeChainNode(obj) {
  function addChainWatcher (line 11129) | function addChainWatcher(obj, keyName, node) {
  function removeChainWatcher (line 11134) | function removeChainWatcher(obj, keyName, node, _meta) {
  function destroyRoot (line 11148) | function destroyRoot(root) {
  function destroyOne (line 11156) | function destroyOne(node) {
  function pushChildren (line 11162) | function pushChildren(node) {
  class ChainNode (line 11175) | class ChainNode {
    method constructor (line 11176) | constructor(parent, key, value) {
    method value (line 11195) | value() {
    method destroy (line 11202) | destroy() {
    method copyTo (line 11211) | copyTo(target) {
    method add (line 11224) | add(path) {
    method remove (line 11232) | remove(path) {
    method chain (line 11243) | chain(key, tails) {
    method unchain (line 11258) | unchain(key, tails) {
    method notify (line 11272) | notify(revalidate, affected) {
    method populateAffected (line 11301) | populateAffected(path, depth, affected) {
  function lazyGet (line 11312) | function lazyGet(obj, key) {
  function finishChains (line 11331) | function finishChains(meta$$1) {
  function watchPath (line 11344) | function watchPath(obj, keyPath, meta$$1) {
  function unwatchPath (line 11353) | function unwatchPath(obj, keyPath, meta$$1) {
  function watch (line 11383) | function watch(obj, keyPath, meta$$1) {
  function isWatching (line 11390) | function isWatching(obj, key) {
  function watcherCount (line 11393) | function watcherCount(obj, key) {
  function unwatch (line 11408) | function unwatch(obj, keyPath, meta$$1) {
  function addDependentKeys (line 11419) | function addDependentKeys(desc, obj, keyName, meta$$1) {
  function removeDependentKeys (line 11434) | function removeDependentKeys(desc, obj, keyName, meta$$1) {
  function expandProperties (line 11484) | function expandProperties(pattern, callback) {
  function dive (line 11498) | function dive(prefix, pattern, start, callback) {
  function set (line 11544) | function set(obj, keyName, value, tolerant) {
  function setPath (line 11603) | function setPath(root, path, value, tolerant) {
  function trySet (line 11638) | function trySet(root, path, value) {
  function noop (line 11646) | function noop() {}
  class ComputedProperty (line 11756) | class ComputedProperty extends Descriptor {
    method constructor (line 11757) | constructor(config, opts) {
    method volatile (line 11800) | volatile() {
    method readOnly (line 11822) | readOnly() {
    method property (line 11852) | property(...passedArgs) {
    method meta (line 11888) | meta(meta$$1) {
    method didChange (line 11897) | didChange(obj, keyName) {
    method get (line 11913) | get(obj, keyName) {
    method set (line 11960) | set(obj, keyName, value) {
    method _throwReadOnlyError (line 11972) | _throwReadOnlyError(obj, keyName) {
    method clobberSet (line 11975) | clobberSet(obj, keyName, value) {
    method volatileSet (line 11981) | volatileSet(obj, keyName, value) {
    method setWithSuspend (line 11984) | setWithSuspend(obj, keyName, value) {
    method _set (line 11993) | _set(obj, keyName, value) {
    method teardown (line 12015) | teardown(obj, keyName, meta$$1) {
  function computed (line 12119) | function computed(...args) {
  function alias (line 12131) | function alias(altKey) {
  class AliasedProperty (line 12134) | class AliasedProperty extends Descriptor {
    method constructor (line 12135) | constructor(altKey) {
    method setup (line 12140) | setup(obj, keyName, meta$$1) {
    method teardown (line 12148) | teardown(obj, keyName, meta$$1) {
    method willWatch (line 12152) | willWatch(obj, keyName, meta$$1) {
    method didUnwatch (line 12155) | didUnwatch(obj, keyName, meta$$1) {
    method get (line 12158) | get(obj, keyName) {
    method unconsume (line 12163) | unconsume(obj, keyName, meta$$1) {
    method consume (line 12172) | consume(obj, keyName, meta$$1) {
    method set (line 12179) | set(obj, _keyName, value) {
    method readOnly (line 12182) | readOnly() {
    method oneWay (line 12186) | oneWay() {
  function AliasedProperty_readOnlySet (line 12191) | function AliasedProperty_readOnlySet(obj, keyName) {
  function AliasedProperty_oneWaySet (line 12195) | function AliasedProperty_oneWaySet(obj, keyName, value) {
  function deprecateProperty (line 12217) | function deprecateProperty(object, deprecatedKey, newKey, options) {
  function isNone (line 12259) | function isNone(obj) {
  function isEmpty (line 12299) | function isEmpty(obj) {
  function isBlank (line 12356) | function isBlank(obj) {
  function isPresent (line 12393) | function isPresent(obj) {
  class Libraries (line 12409) | class Libraries {
    method constructor (line 12410) | constructor() {
    method _getLibraryByName (line 12414) | _getLibraryByName(name) {
    method register (line 12424) | register(name, version, isCoreLibrary) {
    method registerCoreLibrary (line 12437) | registerCoreLibrary(name, version) {
    method deRegister (line 12440) | deRegister(name) {
  function getProperties (line 12502) | function getProperties(obj, keys) {
  function setProperties (line 12543) | function setProperties(obj, properties) {
  method unprocessedNamespaces (line 12567) | get unprocessedNamespaces() {
  method unprocessedNamespaces (line 12570) | set unprocessedNamespaces(v) {
  function addNamespace (line 12578) | function addNamespace(namespace) {
  function removeNamespace (line 12582) | function removeNamespace(namespace) {
  function findNamespaces (line 12590) | function findNamespaces() {
  function findNamespace (line 12608) | function findNamespace(name) {
  function processNamespace (line 12614) | function processNamespace(namespace) {
  function processAllNamespaces (line 12617) | function processAllNamespaces() {
  function classToString (line 12631) | function classToString() {
  function isSearchDisabled (line 12640) | function isSearchDisabled() {
  function setSearchDisabled (line 12643) | function setSearchDisabled(flag) {
  function setUnprocessedMixins (line 12646) | function setUnprocessedMixins() {
  function _processNamespace (line 12649) | function _processNamespace(paths, root, seen) {
  function isUppercase (line 12683) | function isUppercase(code) {
  function tryIsNamespace (line 12687) | function tryIsNamespace(lookup, prop) {
  function calculateToString (line 12695) | function calculateToString(target) {
  function isMethod (line 12724) | function isMethod(obj) {
  function mixinProperties (line 12728) | function mixinProperties(mixinsMeta, mixin) {
  function concatenatedMixinProperties (line 12739) | function concatenatedMixinProperties(concatProp, props, values, base) {
  function giveDescriptorSuper (line 12747) | function giveDescriptorSuper(meta$$1, key, property, values, descs, base) {
  function giveMethodSuper (line 12776) | function giveMethodSuper(obj, key, method, values, descs) {
  function applyConcatenatedProperties (line 12794) | function applyConcatenatedProperties(obj, key, value, values) {
  function applyMergedProperties (line 12807) | function applyMergedProperties(obj, key, value, values) {
  function addNormalizedProperty (line 12834) | function addNormalizedProperty(base, key, value, meta$$1, descs, values,...
  function mergeMixins (line 12855) | function mergeMixins(mixins, meta$$1, descs, values, base, keys) {
  function followAlias (line 12895) | function followAlias(obj, desc, descs, values) {
  function updateObserversAndListeners (line 12911) | function updateObserversAndListeners(obj, key, paths, updateMethod) {
  function replaceObserversAndListeners (line 12918) | function replaceObserversAndListeners(obj, key, prev, next) {
  function applyMixin (line 12928) | function applyMixin(obj, mixins) {
  function mixin (line 12974) | function mixin(obj, ...args) {
  class Mixin (line 13060) | class Mixin {
    method constructor (line 13061) | constructor(mixins, properties) {
    method create (line 13085) | static create(...args) {
    method mixins (line 13093) | static mixins(obj) {
    method reopen (line 13112) | reopen(...args) {
    method apply (line 13132) | apply(obj) {
    method applyPartial (line 13135) | applyPartial(obj) {
    method detect (line 13144) | detect(obj) {
    method without (line 13157) | without(...args) {
    method keys (line 13162) | keys() {
    method toString (line 13165) | toString() {
  function buildMixinsArray (line 13169) | function buildMixinsArray(mixins) {
  function _detect (line 13192) | function _detect(curMixin, targetMixin, seen = new Set()) {
  function _keys (line 13206) | function _keys(mixin, ret = new Set(), seen = new Set()) {
  class Alias (line 13221) | class Alias extends Descriptor {
    method constructor (line 13222) | constructor(methodName) {
    method teardown (line 13226) | teardown(_obj, _keyName, _meta) {
    method get (line 13229) | get(_obj, _keyName) {
    method set (line 13232) | set(_obj, _keyName, _value) {
  function aliasMethod (line 13265) | function aliasMethod(methodName) {
  function observer (line 13296) | function observer(...args) {
  class InjectedProperty (line 13326) | class InjectedProperty extends ComputedProperty {
    method constructor (line 13327) | constructor(type, name, options) {
  function injectedPropertyGet (line 13347) | function injectedPropertyGet(keyName) {
  function descriptor (line 13360) | function descriptor(desc) {
  class NativeDescriptor (line 13371) | class NativeDescriptor extends Descriptor {
    method constructor (line 13372) | constructor(desc) {
    method setup (line 13378) | setup(obj, key, meta$$1) {
    method get (line 13382) | get(obj, key) {
    method set (line 13385) | set(obj, key, value) {
  function getOwner (line 13529) | function getOwner(object) {
  function setOwner (line 13544) | function setOwner(object, owner) {
  method _qpChanged (line 13698) | _qpChanged(controller, _prop) {
  method transitionToRoute (line 13762) | transitionToRoute(...args) {
  method replaceRoute (line 13814) | replaceRoute(...args) {
  method create (line 13844) | create(options) {
  class AutoLocation (line 13909) | class AutoLocation extends _runtime.Object {
    method constructor (line 13910) | constructor() {
    method detect (line 13920) | detect() {
    method willDestroy (line 13942) | willDestroy() {
  function delegateToConcreteImplementation (line 14009) | function delegateToConcreteImplementation(methodName) {
  function detectImplementation (line 14017) | function detectImplementation(options) {
  function getHistoryPath (line 14061) | function getHistoryPath(rootURL, location) {
  function getHashPath (line 14100) | function getHashPath(rootURL, location) {
  class HashLocation (line 14147) | class HashLocation extends _runtime.Object {
    method constructor (line 14148) | constructor() {
    method init (line 14152) | init() {
    method getHash (line 14162) | getHash() {
    method getURL (line 14173) | getURL() {
    method setURL (line 14196) | setURL(path) {
    method replaceURL (line 14207) | replaceURL(path) {
    method onUpdateURL (line 14219) | onUpdateURL(callback) {
    method formatURL (line 14240) | formatURL(url) {
    method willDestroy (line 14248) | willDestroy() {
    method _removeEventListener (line 14251) | _removeEventListener() {
  function _uuid (line 14266) | function _uuid() {
  class HistoryLocation (line 14304) | class HistoryLocation extends _runtime.Object {
    method constructor (line 14305) | constructor() {
    method getHash (line 14321) | getHash() {
    method init (line 14324) | init() {
    method initState (line 14340) | initState() {
    method getURL (line 14362) | getURL() {
    method setURL (line 14382) | setURL(path) {
    method replaceURL (line 14396) | replaceURL(path) {
    method getState (line 14415) | getState() {
    method pushState (line 14427) | pushState(path) {
    method replaceState (line 14440) | replaceState(path) {
    method onUpdateURL (line 14454) | onUpdateURL(callback) {
    method formatURL (line 14475) | formatURL(url) {
    method willDestroy (line 14494) | willDestroy() {
    method _removeEventListener (line 14497) | _removeEventListener() {
  class NoneLocation (line 14525) | class NoneLocation extends _runtime.Object {
    method constructor (line 14526) | constructor() {
    method detect (line 14530) | detect() {
    method getURL (line 14540) | getURL() {
    method setURL (line 14555) | setURL(path) {
    method onUpdateURL (line 14566) | onUpdateURL(callback) {
    method handleURL (line 14575) | handleURL(url) {
    method formatURL (line 14589) | formatURL(url) {
  function getPath (line 14626) | function getPath(location) {
  function getQuery (line 14639) | function getQuery(location) {
  function getHash (line 14647) | function getHash(location) {
  function getFullPath (line 14653) | function getFullPath(location) {
  function getOrigin (line 14656) | function getOrigin(location) {
  function supportsHashChange (line 14676) | function supportsHashChange(documentMode, global) {
  function supportsHistory (line 14687) | function supportsHistory(userAgent, history) {
  function replacePath (line 14705) | function replacePath(location, path) {
  class RouterService (line 14752) | class RouterService extends _service.default {
    method transitionTo (line 14770) | transitionTo(...args) {
    method replaceWith (line 14796) | replaceWith() /* routeNameOrUrl, ...models, options */{
    method urlFor (line 14810) | urlFor(routeName, ...args) {
    method isActive (line 14824) | isActive(...args) {
  method init (line 14931) | init() {
  method recognize (line 14966) | recognize(url) {
  method recognizeAndLoad (line 14983) | recognizeAndLoad(url) {
  class RoutingService (line 15008) | class RoutingService extends _service.default {
    method hasRoute (line 15009) | hasRoute(routeName) {
    method transitionTo (line 15012) | transitionTo(routeName, models, queryParams, shouldReplace) {
    method normalizeQueryParams (line 15020) | normalizeQueryParams(routeName, models, queryParams) {
    method generateURL (line 15023) | generateURL(routeName, models, queryParams) {
    method isActiveForRoute (line 15038) | isActiveForRoute(contexts, queryParams, routeName, routerState, isCurr...
  function numberOfContextsAcceptedByHandler (line 15065) | function numberOfContextsAcceptedByHandler(handlerName, handlerInfos) {
  class BucketCache (line 15086) | class BucketCache {
    method constructor (line 15087) | constructor() {
    method has (line 15090) | has(bucketKey) {
    method stash (line 15093) | stash(bucketKey, key, value) {
    method lookup (line 15101) | lookup(bucketKey, prop, defaultValue) {
  function controllerFor (line 15129) | function controllerFor(container, controllerName, lookupOptions) {
  class DSL (line 15137) | class DSL {
    method constructor (line 15138) | constructor(name = null, options) {
    method route (line 15145) | route(name, options = {}, callback) {
    method push (line 15183) | push(url, name, callback, serialize) {
    method generate (line 15200) | generate() {
    method mount (line 15211) | mount(_name, options = {}) {
  function canNest (line 15274) | function canNest(dsl) {
  function getFullName (line 15277) | function getFullName(dsl, name, resetNamespace) {
  function createRoute (line 15284) | function createRoute(dsl, name, options = {}, callback) {
  function generateControllerFactory (line 15312) | function generateControllerFactory(owner, controllerName) {
  function generateController (line 15332) | function generateController(owner, controllerName) {
  class QueryParams (line 15347) | class QueryParams {
    method constructor (line 15348) | constructor(values = null) {
  function defaultSerialize (line 15573) | function defaultSerialize(model, params) {
  function hasDefaultSerialize (line 15590) | function hasDefaultSerialize(route) {
  class Route (line 15607) | class Route extends _runtime.Object {
    method constructor (line 15608) | constructor() {
    method _setRouteName (line 15640) | _setRouteName(name) {
    method _stashNames (line 15648) | _stashNames(routeInfo, dynamicParent) {
    method _activeQPChanged (line 15673) | _activeQPChanged(qp, value) {
    method _updatingQPChanged (line 15680) | _updatingQPChanged(qp) {
    method paramsFor (line 15723) | paramsFor(name) {
    method serializeQueryParamKey (line 15746) | serializeQueryParamKey(controllerPropertyName) {
    method serializeQueryParam (line 15757) | serializeQueryParam(value, _urlKey, defaultValueType) {
    method deserializeQueryParam (line 15771) | deserializeQueryParam(value, _urlKey, defaultValueType) {
    method _optionsForQueryParam (line 15781) | _optionsForQueryParam(qp) {
    method resetController (line 15804) | resetController(_controller, _isExiting, _transition) {
    method exit (line 15811) | exit() {
    method _internalReset (line 15821) | _internalReset(isExiting, transition) {
    method enter (line 15830) | enter() {
    method deactivate (line 16009) | deactivate() {}
    method activate (line 16017) | activate() {}
    method transitionTo (line 16167) | transitionTo(...args) {
    method intermediateTransitionTo (line 16186) | intermediateTransitionTo(...args) {
    method refresh (line 16209) | refresh() {
    method replaceWith (line 16247) | replaceWith(...args) {
    method setup (line 16255) | setup(context, transition) {
    method _qpChanged (line 16301) | _qpChanged(prop, value, qp) {
    method beforeModel (line 16338) | beforeModel() {}
    method afterModel (line 16370) | afterModel() {}
    method redirect (line 16394) | redirect() {}
    method contextDidChange (line 16400) | contextDidChange() {
    method model (line 16463) | model(params, transition) {
    method deserialize (line 16497) | deserialize(_params, transition) {
    method findModel (line 16509) | findModel(...args) {
    method setupController (line 16565) | setupController(controller, context, _transition) {
    method controllerFor (line 16591) | controllerFor(name, _skipAssert) {
    method generateController (line 16622) | generateController(name) {
    method modelFor (line 16660) | modelFor(_name) {
    method renderTemplate (line 16710) | renderTemplate(_controller, _model) {
    method render (line 16816) | render(_name, options) {
    method disconnectOutlet (line 16879) | disconnectOutlet(options) {
    method _disconnectOutlet (line 16902) | _disconnectOutlet(outletName, parentView) {
    method willDestroy (line 16928) | willDestroy() {
    method teardownViews (line 16935) | teardownViews() {
  function parentRoute (line 16945) | function parentRoute(route) {
  function routeInfoFor (line 16949) | function routeInfoFor(route, routeInfos, offset = 0) {
  function buildRenderOptions (line 16962) | function buildRenderOptions(route, isDefaultRender, _name, options) {
  function getFullQueryParams (line 17021) | function getFullQueryParams(router, state) {
  function getQueryParamsFor (line 17030) | function getQueryParamsFor(route, state) {
  function copyDefaultValue (line 17049) | function copyDefaultValue(value) {
  function mergeEachQueryParams (line 17060) | function mergeEachQueryParams(controllerQP, routeQP) {
  function addQueryParamsObservers (line 17092) | function addQueryParamsObservers(controller, propNames) {
  function getEngineRouteName (line 17097) | function getEngineRouteName(engine, routeName) {
  method find (line 17258) | find(name, value) {
  method send (line 17418) | send(...args) {
  method queryParamsDidChange (line 17466) | queryParamsDidChange(changed, _totalPresent, removed) {
  method finalizeQueryParamChange (line 17478) | finalizeQueryParamChange(params, finalParams, transition) {
  method on (line 17559) | on(name) {
  method _paramsFor (line 17580) | _paramsFor(routeName, params) {
  function defaultDidTransition (line 17596) | function defaultDidTransition(infos) {
  function defaultWillTransition (line 17611) | function defaultWillTransition(oldInfos, newInfos, transition) {
  method get (line 17622) | get() {
  method get (line 17634) | get() {
  method get (line 17646) | get() {
  method get (line 17660) | get() {
  method set (line 17670) | set(value) {
  method get (line 17682) | get() {
  method get (line 17694) | get() {
  method get (line 17706) | get() {
  function K (line 17728) | function K() {
  class EmberRouter (line 17741) | class EmberRouter extends _runtime.Object {
    method constructor (line 17742) | constructor() {
    method _initRouterJs (line 17747) | _initRouterJs() {
    method _buildDSL (line 17895) | _buildDSL() {
    method init (line 17912) | init() {
    method _resetQueuedQueryParameterChanges (line 17932) | _resetQueuedQueryParameterChanges() {
    method _hasModuleBasedResolver (line 17935) | _hasModuleBasedResolver() {
    method startRouting (line 17951) | startRouting() {
    method setupRouter (line 17963) | setupRouter() {
    method _setOutlets (line 17977) | _setOutlets() {
    method handleURL (line 18026) | handleURL(url) {
    method _doURLTransition (line 18032) | _doURLTransition(routerJsMethod, url) {
    method transitionTo (line 18051) | transitionTo(...args) {
    method intermediateTransitionTo (line 18062) | intermediateTransitionTo(name, ...args) {
    method replaceWith (line 18073) | replaceWith(...args) {
    method generate (line 18076) | generate(name, ...args) {
    method isActive (line 18087) | isActive(routeName) {
    method isActiveIntent (line 18102) | isActiveIntent(routeName, models, queryParams) {
    method send (line 18105) | send(name, ...args) {
    method hasRoute (line 18115) | hasRoute(route) {
    method reset (line 18124) | reset() {
    method willDestroy (line 18129) | willDestroy() {
    method _activeQPChanged (line 18148) | _activeQPChanged(queryParameterName, newValue) {
    method _updatingQPChanged (line 18152) | _updatingQPChanged(queryParameterName) {
    method _fireQueryParamTransition (line 18168) | _fireQueryParamTransition() {
    method _setupLocation (line 18172) | _setupLocation() {
    method _serializeQueryParams (line 18213) | _serializeQueryParams(routeInfos, queryParams) {
    method _serializeQueryParam (line 18232) | _serializeQueryParam(value, type) {
    method _deserializeQueryParams (line 18248) | _deserializeQueryParams(routeInfos, queryParams) {
    method _deserializeQueryParam (line 18265) | _deserializeQueryParam(value, defaultType) {
    method _pruneDefaultQueryParamValues (line 18286) | _pruneDefaultQueryParamValues(routeInfos, queryParams) {
    method _doTransition (line 18295) | _doTransition(_targetRouteName, models, _queryParams, _keepDefaultQuer...
    method _processActiveTransitionQueryParams (line 18307) | _processActiveTransitionQueryParams(targetRouteName, models, queryPara...
    method _prepareQueryParams (line 18339) | _prepareQueryParams(targetRouteName, models, queryParams, _fromRouterS...
    method _getQPMeta (line 18355) | _getQPMeta(routeInfo) {
    method _queryParamsFor (line 18367) | _queryParamsFor(routeInfos) {
    method _fullyScopeQueryParams (line 18419) | _fullyScopeQueryParams(leafRouteName, contexts, queryParams) {
    method _hydrateUnsuppliedQueryParams (line 18452) | _hydrateUnsuppliedQueryParams(state, queryParams, _fromRouterService) {
    method _scheduleLoadingEvent (line 18494) | _scheduleLoadingEvent(transition, originRoute) {
    method _handleSlowTransition (line 18498) | _handleSlowTransition(transition, originRoute) {
    method _cancelSlowTransitionTimer (line 18508) | _cancelSlowTransitionTimer() {
    method _markErrorAsHandled (line 18516) | _markErrorAsHandled(error) {
    method _isErrorHandled (line 18519) | _isErrorHandled(error) {
    method _clearHandledError (line 18522) | _clearHandledError(error) {
    method _getEngineInstance (line 18525) | _getEngineInstance({ name, instanceId, mountPoint }) {
  function forEachRouteAbove (line 18560) | function forEachRouteAbove(routeInfos, callback) {
  method willResolveModel (line 18582) | willResolveModel(_routeInfos, transition, originRoute) {
  method error (line 18586) | error(routeInfos, error, transition) {
  method loading (line 18613) | loading(routeInfos, transition) {
  function logError (line 18638) | function logError(_error, initialMessage) {
  function findRouteSubstateName (line 18671) | function findRouteSubstateName(route, state) {
  function findRouteStateName (line 18688) | function findRouteStateName(route, state) {
  function routeHasBeenDefined (line 18706) | function routeHasBeenDefined(owner, router, localName, fullName) {
  function triggerEvent (line 18711) | function triggerEvent(routeInfos, ignoreFailure, name, args) {
  function calculatePostTransitionState (line 18745) | function calculatePostTransitionState(emberRouter, leafRouteName, contex...
  function updatePaths (line 18759) | function updatePaths(router) {
  method map (line 18821) | map(callback) {
  method _routePath (line 18829) | _routePath(routeInfos) {
  function didBeginTransition (line 18858) | function didBeginTransition(transition, router) {
  function forEachQueryParam (line 18872) | function forEachQueryParam(router, routeInfos, queryParams, callback) {
  function findLiveRoute (line 18883) | function findLiveRoute(liveRoutes, name) {
  function appendLiveRoute (line 18900) | function appendLiveRoute(liveRoutes, defaultParentState, renderOptions) {
  function representEmptyRoute (line 18922) | function representEmptyRoute(liveRoutes, defaultParentState, route) {
  class RouterState (line 19020) | class RouterState {
    method constructor (line 19021) | constructor(emberRouter, router, routerJsState) {
    method isActiveIntent (line 19026) | isActiveIntent(routeName, models, queryParams, queryParamsMustMatch) {
  function extractRouteArgs (line 19215) | function extractRouteArgs(args) {
  function getActiveTargetName (line 19227) | function getActiveTargetName(router) {
  function stashParamNames (line 19231) | function stashParamNames(router, routeInfos) {
  function _calculateCacheValuePrefix (line 19254) | function _calculateCacheValuePrefix(prefix, part) {
  function calculateCacheKey (line 19275) | function calculateCacheKey(prefix, parts = [], values) {
  function normalizeControllerQueryParams (line 19325) | function normalizeControllerQueryParams(queryParams) {
  function accumulateQueryParamDescriptors (line 19332) | function accumulateQueryParamDescriptors(_desc, accum) {
  function resemblesURL (line 19358) | function resemblesURL(str) {
  function prefixRouteNameArg (line 19366) | function prefixRouteNameArg(route, args) {
  function shallowEqual (line 19381) | function shallowEqual(a, b) {
  function spaceship (line 19641) | function spaceship(a, b) {
  function compare (line 19696) | function compare(v, w) {
  function _copy (line 19767) | function _copy(obj, deep, seen, copies) {
  function copy (line 19855) | function copy(obj, deep) {
  function onerrorDefault (line 20020) | function onerrorDefault(reason) {
  function errorFor (line 20032) | function errorFor(reason) {
  function unwrapErrorThrown (line 20052) | function unwrapErrorThrown(reason) {
  function isEqual (line 20119) | function isEqual(a, b) {
  function contentPropertyDidChange (line 20137) | function contentPropertyDidChange(content, contentKey) {
  function contentFor (line 20147) | function contentFor(proxy, m) {
  method init (line 20174) | init() {
  method willDestroy (line 20181) | willDestroy() {
  method willWatchProperty (line 20190) | willWatchProperty(key) {
  method didUnwatchProperty (line 20195) | didUnwatchProperty(key) {
  method unknownProperty (line 20200) | unknownProperty(key) {
  method setUnknownProperty (line 20207) | setUnknownProperty(key, value) {
  method send (line 20391) | send(actionName, ...args) {
  function isEmberArray (line 20426) | function isEmberArray(obj) {
  function uniqBy (line 20432) | function uniqBy(array, key = identityFunction) {
  function iter (line 20450) | function iter(key, value) {
  function findIndex (line 20455) | function findIndex(array, predicate, startAt) {
  function find (line 20466) | function find(array, callback, target) {
  function any (line 20472) | function any(array, callback, target) {
  function every (line 20477) | function every(array, callback, target) {
  function indexOf (line 20483) | function indexOf(array, val, startAt = 0, withNaNCheck) {
  function removeAt (line 20495) | function removeAt(array, index, len = 1) {
  function insertAt (line 20502) | function insertAt(array, index, item) {
  function isArray (line 20537) | function isArray(_obj) {
  function nonEnumerableComputed (line 20570) | function nonEnumerableComputed() {
  method objectsAt (line 20656) | objectsAt(indexes) {
  method get (line 20669) | get() {
  method set (line 20672) | set(key, value) {
  method slice (line 20715) | slice(beginIndex = 0, endIndex) {
  method indexOf (line 20757) | indexOf(object, startAt) {
  method lastIndexOf (line 20781) | lastIndexOf(object, startAt) {
  method addArrayObserver (line 20827) | addArrayObserver(target, opts) {
  method removeArrayObserver (line 20842) | removeArrayObserver(target, opts) {
  method arrayContentWillChange (line 20870) | arrayContentWillChange(startIdx, removeAmt, addAmt) {
  method arrayContentDidChange (line 20888) | arrayContentDidChange(startIdx, removeAmt, addAmt) {
  method forEach (line 20913) | forEach(callback, target = null) {
  method setEach (line 20946) | setEach(key, value) {
  method map (line 20971) | map(callback, target = null) {
  method mapBy (line 20989) | mapBy(key) {
  method filter (line 21016) | filter(callback, target = null) {
  method reject (line 21051) | reject(callback, target = null) {
  method filterBy (line 21069) | filterBy() {
  method rejectBy (line 21083) | rejectBy() {
  method find (line 21109) | find(callback, target = null) {
  method findBy (line 21126) | findBy() {
  method every (line 21157) | every(callback, target = null) {
  method isEvery (line 21176) | isEvery() {
  method any (line 21209) | any(callback, target = null) {
  method isAny (line 21226) | isAny() {
  method reduce (line 21256) | reduce(callback, initialValue) {
  method invoke (line 21278) | invoke(methodName, ...args) {
  method toArray (line 21293) | toArray() {
  method compact (line 21307) | compact() {
  method includes (line 21333) | includes(object, startAt) {
  method sortBy (line 21350) | sortBy() {
  method uniq (line 21381) | uniq() {
  method uniqBy (line 21400) | uniqBy(key) {
  method without (line 21417) | without(value) {
  method clear (line 21511) | clear() {
  method insertAt (line 21535) | insertAt(idx, object) {
  method removeAt (line 21557) | removeAt(start, len) {
  method pushObject (line 21574) | pushObject(obj) {
  method pushObjects (line 21590) | pushObjects(objects) {
  method popObject (line 21607) | popObject() {
  method shiftObject (line 21630) | shiftObject() {
  method unshiftObject (line 21653) | unshiftObject(obj) {
  method unshiftObjects (line 21670) | unshiftObjects(objects) {
  method reverseObjects (line 21682) | reverseObjects() {
  method setObjects (line 21707) | setObjects(objects) {
  method removeObject (line 21730) | removeObject(obj) {
  method removeObjects (line 21749) | removeObjects(objects) {
  method addObject (line 21771) | addObject(obj) {
  method addObjects (line 21788) | addObjects(objects) {
  method objectAt (line 21851) | objectAt(idx) {
  method replace (line 21856) | replace(start, deleteCount, items = EMPTY_ARRAY) {
  method copy (line 21864) | copy(deep) {
  method ownerInjection (line 21979) | ownerInjection() {
  method lookup (line 22014) | lookup(fullName, options) {
  method destroy (line 22018) | destroy() {
  method factoryFor (line 22061) | factoryFor(fullName, options = {}) {
  method on (line 22113) | on(name, target, method) {
  method one (line 22132) | one(name, target, method) {
  method trigger (line 22153) | trigger(name, ...args) {
  method off (line 22166) | off(name, target, method) {
  method has (line 22178) | has(name) {
  method get (line 22223) | get(keyName) {
  method getProperties (line 22244) | getProperties(...args) {
  method set (line 22283) | set(keyName, value) {
  method setProperties (line 22299) | setProperties(hash) {
  method beginPropertyChanges (line 22316) | beginPropertyChanges() {
  method endPropertyChanges (line 22333) | endPropertyChanges() {
  method notifyPropertyChange (line 22349) | notifyPropertyChange(keyName) {
  method addObserver (line 22390) | addObserver(key, target, method) {
  method removeObserver (line 22406) | removeObserver(key, target, method) {
  method hasObserverFor (line 22421) | hasObserverFor(key) {
  method getWithDefault (line 22437) | getWithDefault(keyName, defaultValue) {
  method incrementProperty (line 22453) | incrementProperty(keyName, increment = 1) {
  method decrementProperty (line 22471) | decrementProperty(keyName, decrement = 1) {
  method toggleProperty (line 22488) | toggleProperty(keyName) {
  method cacheFor (line 22502) | cacheFor(keyName) {
  function tap (line 22514) | function tap(proxy, promise) {
  method get (line 22664) | get() {
  method set (line 22667) | set(key, promise) {
  function promiseAlias (line 22706) | function promiseAlias(name) {
  method resolveRegistration (line 22726) | resolveRegistration(fullName, options) {
  function registryAlias (line 22916) | function registryAlias(name) {
  method get (line 22930) | get() {
  method set (line 22937) | set(value) {
  method triggerAction (line 23011) | triggerAction(opts = {}) {
  function getTarget (line 23041) | function getTarget(instance) {
  class ArrayProxy (line 23136) | class ArrayProxy extends _object.default {
    method init (line 23137) | init() {
    method willDestroy (line 23158) | willDestroy() {
    method objectAtContent (line 23180) | objectAtContent(idx) {
    method replace (line 23186) | replace(idx, amt, objects) {
    method replaceContent (line 23205) | replaceContent(idx, amt, objects) {
    method objectAt (line 23210) | objectAt(idx) {
    method length (line 23233) | get length() {
    method length (line 23243) | set length(value) {
    method _addArrangedContentArrayObsever (line 23281) | _addArrangedContentArrayObsever() {
    method _removeArrangedContentArrayObsever (line 23293) | _removeArrangedContentArrayObsever() {
    method _arrangedContentArrayWillChange (line 23299) | _arrangedContentArrayWillChange() {}
    method _arrangedContentArrayDidChange (line 23301) | _arrangedContentArrayDidChange(proxy, idx, removedCnt, addedCnt) {
    method _invalidate (line 23323) | _invalidate() {
  method [_metal.PROPERTY_DID_CHANGE] (line 23263) | [_metal.PROPERTY_DID_CHANGE](key) {
  function initialize (line 23365) | function initialize(obj, properties) {
  class CoreObject (line 23436) | class CoreObject {
    method _initFactory (line 23437) | static _initFactory(factory) {
    method constructor (line 23441) | constructor(properties) {
    method reopen (line 23501) | reopen(...args) {
    method init (line 23530) | init() {}
    method isDestroyed (line 23661) | get isDestroyed() {
    method isDestroyed (line 23665) | set isDestroyed(value) {
    method isDestroying (line 23677) | get isDestroying() {
    method isDestroying (line 23681) | set isDestroying(value) {
    method destroy (line 23696) | destroy() {
    method willDestroy (line 23715) | willDestroy() {}
    method _scheduledDestroy (line 23723) | _scheduledDestroy(m) {
    method toString (line 23763) | toString() {
    method extend (line 23846) | static extend() {
    method create (line 23884) | static create(props, extra) {
    method reopen (line 23923) | static reopen() {
    method willReopen (line 23929) | static willReopen() {
    method reopenClass (line 23990) | static reopenClass() {
    method detect (line 23995) | static detect(obj) {
    method detectInstance (line 24008) | static detectInstance(obj) {
    method metaForProperty (line 24036) | static metaForProperty(key) {
    method eachComputedProperty (line 24054) | static eachComputedProperty(callback, binding = this) {
    method PrototypeMixin (line 24066) | static get PrototypeMixin() {
    method superclass (line 24076) | static get superclass() {
    method proto (line 24081) | static proto() {
  function flattenProps (line 24106) | function flattenProps(...props) {
  class Namespace (line 24217) | class Namespace extends _object.default {
    method init (line 24218) | init() {
    method toString (line 24222) | toString() {
    method nameClasses (line 24236) | nameClasses() {
    method destroy (line 24240) | destroy() {
  class EmberObject (line 24275) | class EmberObject extends _core_object.default {
    method _debugContainerKey (line 24276) | get _debugContainerKey() {
  method [_owner.OWNER] (line 24281) | get [_owner.OWNER]() {
  method [_owner.OWNER] (line 24292) | set [_owner.OWNER](value) {
  method init (line 24309) | init() {
  method [ASSERT_INIT_WAS_CALLED] (line 24314) | [ASSERT_INIT_WAS_CALLED]() {
  class ObjectProxy (line 24401) | class ObjectProxy extends _object.default {}
  function typeOf (line 24491) | function typeOf(item) {
  function intern (line 24562) | function intern(str) {
  function isObject (line 24584) | function isObject(value) {
  function uuid (line 24607) | function uuid() {
  function generateGuid (line 24655) | function generateGuid(obj, prefix = GUID_PREFIX) {
  function guidFor (line 24676) | function guidFor(value) {
  function isInternalSymbol (line 24704) | function isInternalSymbol(possibleSymbol) {
  function symbol (line 24707) | function symbol(debugName) {
  function makeDictionary (line 24722) | function makeDictionary(parent) {
  function hasSuper (line 24747) | function hasSuper(func) {
  function setObservers (line 24756) | function setObservers(func, observers) {
  function getObservers (line 24761) | function getObservers(func) {
  function setListeners (line 24765) | function setListeners(func, listeners) {
  function getListeners (line 24770) | function getListeners(func) {
  function wrap (line 24786) | function wrap(func, superFunc) {
  function _wrap (line 24796) | function _wrap(func, superFunc) {
  function inspect (line 24835) | function inspect(obj) {
  function inspectValue (line 24842) | function inspectValue(value, depth, seen) {
  function inspectKey (line 24877) | function inspectKey(key) {
  function inspectObject (line 24880) | function inspectObject(obj, depth, seen) {
  function inspectArray (line 24898) | function inspectArray(arr, depth, seen) {
  function lookupDescriptor (line 24915) | function lookupDescriptor(obj, keyName) {
  function canInvoke (line 24945) | function canInvoke(obj, methodName) {
  function tryInvoke (line 24974) | function tryInvoke(obj, methodName, args) {
  function makeArray (line 24982) | function makeArray(obj) {
  function setName (line 24990) | function setName(obj, name) {
  function getName (line 24993) | function getName(obj) {
  function isNone (line 24998) | function isNone(obj) {
  function toString (line 25005) | function toString(obj) {
  function isProxy (line 25043) | function isProxy(object) {
  function setProxy (line 25049) | function setProxy(object) {
  class Cache (line 25055) | class Cache {
    method constructor (line 25056) | constructor(limit, func, store) {
    method get (line 25065) | get(key) {
    method set (line 25076) | set(key, value) {
    method purge (line 25083) | purge() {
  method componentFor (line 25320) | componentFor(name, owner, options) {
  method layoutFor (line 25327) | layoutFor(name, owner, options) {
  method send (line 25339) | send(actionName, ...args) {
  method get (line 25502) | get() {
  method appendChild (line 25507) | appendChild(view) {
  method init (line 25528) | init() {
  method init (line 25717) | init() {
  method interpretKeyEvents (line 25739) | interpretKeyEvents(event) {
  method _elementValueDidChange (line 25749) | _elementValueDidChange() {
  method change (line 25753) | change(event) {
  method insertNewline (line 25769) | insertNewline(event) {
  method cancel (line 25785) | cancel(event) {
  method focusIn (line 25800) | focusIn(event) {
  method focusOut (line 25815) | focusOut(event) {
  method keyPress (line 25831) | keyPress(event) {
  method keyUp (line 25846) | keyUp(event) {
  method keyDown (line 25862) | keyDown(event) {
  function sendAction (line 25871) | function sendAction(eventName, view, event) {
  method _transitionTo (line 25899) | _transitionTo(state) {
  function K (line 25916) | function K() {
  method nearestOfType (line 25982) | nearestOfType(klass) {
  method nearestWithProperty (line 26002) | nearestWithProperty(property) {
  method rerender (line 26027) | rerender() {
  method get (line 26044) | get() {
  method $ (line 26060) | $(sel) {
  method appendTo (line 26083) | appendTo(selector) {
  method append (line 26135) | append() {
  method findElementInParentElement (line 26177) | findElementInParentElement(parentElem) {
  method destroy (line 26217) | destroy() {
  method init (line 26278) | init() {
  method handleEvent (line 26306) | handleEvent(eventName, evt) {
  function ActionManager (line 26319) | function ActionManager() {}
  method init (line 26427) | init() {
  method setup (line 26452) | setup(addedEvents, _rootElement) {
  method setupHandler (line 26527) | setupHandler(rootElement, event, eventName, viewRegistry) {
  method _getViewRegistry (line 26684) | _getViewRegistry() {
  method destroy (line 26691) | destroy() {
  method toString (line 26717) | toString() {
  function addJQueryEventDeprecation (line 26756) | function addJQueryEventDeprecation(jqEvent) {
  function parseUnderscoredName (line 26818) | function parseUnderscoredName(templateName) {
  function lookupPartial (line 26827) | function lookupPartial(templateName, owner) {
  function hasPartial (line 26839) | function hasPartial(name, owner) {
  function templateFor (line 26847) | function templateFor(owner, underscored, name) {
  function isSimpleClick (line 26887) | function isSimpleClick(event) {
  function constructStyleDeprecationMessage (line 26894) | function constructStyleDeprecationMessage(affectedStyle) {
  function getRootViews (line 26903) | function getRootViews(owner) {
  function getViewId (line 26924) | function getViewId(view) {
  function getViewElement (line 26939) | function getViewElement(view) {
  function initViewElement (line 26943) | function initViewElement(view) {
  function setViewElement (line 26947) | function setViewElement(view, element) {
  function getChildViews (line 26958) | function getChildViews(view) {
  function initChildViews (line 26964) | function initChildViews(view) {
  function addChildView (line 26970) | function addChildView(parent, child) {
  function collectChildViews (line 26979) | function collectChildViews(view, registry) {
  function getViewBounds (line 27000) | function getViewBounds(view) {
  function getViewRange (line 27009) | function getViewRange(view) {
  function getViewClientRects (line 27030) | function getViewClientRects(view) {
  function getViewBoundingClientRect (line 27046) | function getViewBoundingClientRect(view) {
  function matches (line 27061) | function matches(el, selector) {
  function contains (line 27065) | function contains(a, b) {
  function lookupModuleUnificationComponentPair (line 27083) | function lookupModuleUnificationComponentPair(componentLookup, owner, na...
  function lookupComponentPair (line 27105) | function lookupComponentPair(componentLookup, owner, name, options) {
  function lookupComponent (line 27118) | function lookupComponent(owner, name, options) {
  method init (line 27156) | init() {
  method instrumentDetails (line 27178) | instrumentDetails(hash) {
  method trigger (line 27192) | trigger(name, ...args) {
  method has (line 27200) | has(name) {
  function cloneStates (line 27216) | function cloneStates(from) {
  method appendChild (line 27263) | appendChild() {
  method handleEvent (line 27268) | handleEvent() {
  method rerender (line 27272) | rerender() {}
  method destroy (line 27274) | destroy() {}
  method appendChild (line 27283) | appendChild() {
  method rerender (line 27286) | rerender() {
  method rerender (line 27299) | rerender(view) {
  method destroy (line 27303) | destroy(view) {
  method handleEvent (line 27308) | handleEvent(view, eventName, event) {
  method enter (line 27329) | enter(view) {
  method exit (line 27341) | exit(view) {
  class DefaultResolver (line 27425) | class DefaultResolver extends _runtime.Object {
    method create (line 27426) | static create(props) {
    method init (line 27440) | init() {
    method normalize (line 27444) | normalize(fullName) {
    method resolve (line 27467) | resolve(fullName) {
    method parseName (line 27500) | parseName(fullName) {
    method _parseName (line 27504) | _parseName(fullName) {
    method lookupDescription (line 27548) | lookupDescription(fullName) {
    method makeToString (line 27565) | makeToString(factory) {
    method useRouterNaming (line 27577) | useRouterNaming(parsedName) {
    method resolveTemplate (line 27591) | resolveTemplate(parsedName) {
    method resolveView (line 27604) | resolveView(parsedName) {
    method resolveController (line 27616) | resolveController(parsedName) {
    method resolveRoute (line 27627) | resolveRoute(parsedName) {
    method resolveModel (line 27639) | resolveModel(parsedName) {
    method resolveHelper (line 27653) | resolveHelper(parsedName) {
    method resolveOther (line 27664) | resolveOther(parsedName) {
    method resolveMain (line 27670) | resolveMain(parsedName) {
    method knownForType (line 27681) | knownForType(type) {
    method translateToContainerFullname (line 27711) | translateToContainerFullname(type, name) {
  method init (line 27846) | init() {
  method _bootSync (line 27872) | _bootSync(options) {
  method setupRegistry (line 27903) | setupRegistry(options) {
  method didCreateRootView (line 27921) | didCreateRootView(view) {
  method startRouting (line 27931) | startRouting() {
  method setupRouter (line 27944) | setupRouter() {
  method handleURL (line 27960) | handleURL(url) {
  method setupEventDispatcher (line 27970) | setupEventDispatcher() {
  method getURL (line 27988) | getURL() {
  method visit (line 28004) | visit(url) {
  method willDestroy (line 28042) | willDestroy() {
  method setupRegistry (line 28055) | setupRegistry(registry, options = {}) {
  class BootOptions (line 28093) | class BootOptions {
    method constructor (line 28094) | constructor(options = {}) {
    method toEnvironment (line 28244) | toEnvironment() {
  method init (line 28568) | init() {
  method buildInstance (line 28609) | buildInstance(options = {}) {
  method _watchInstance (line 28621) | _watchInstance(instance) {
  method _unwatchInstance (line 28631) | _unwatchInstance(instance) {
  method _prepareForGlobalsMode (line 28644) | _prepareForGlobalsMode() {
  method _buildDeprecatedInstance (line 28665) | _buildDeprecatedInstance() {
  method waitForDOMReady (line 28686) | waitForDOMReady() {
  method domReady (line 28723) | domReady() {
  method deferReadiness (line 28754) | deferReadiness() {
  method advanceReadiness (line 28769) | advanceReadiness() {
  method boot (line 28792) | boot() {
  method _bootSync (line 28818) | _bootSync() {
  method reset (line 28899) | reset() {
  method didBecomeReady (line 28925) | didBecomeReady() {
  method ready (line 28978) | ready() {
  method willDestroy (line 28983) | willDestroy() {
  method visit (line 29152) | visit(url, options) {
  method buildRegistry (line 29187) | buildRegistry() {
  function commonSetupRegistry (line 29199) | function commonSetupRegistry(registry) {
  function registerLibraries (line 29227) | function registerLibraries() {
  function onLoad (line 29279) | function onLoad(name, callback) {
  function runLoadHooks (line 29301) | function runLoadHooks(name, object) {
  function validateType (line 29327) | function validateType(resolvedType, parsedName) {
  function isEnabled (line 29392) | function isEnabled(feature) {
  function featureValue (line 29402) | function featureValue(value) {
  function inject (line 29466) | function inject(name, options) {
  function isTesting (line 29960) | function isTesting() {
  function setTesting (line 29963) | function setTesting(value) {
  function props (line 30091) | function props(obj) {
  method init (line 30118) | init() {
  method ensureInitializers (line 30136) | ensureInitializers() {
  method buildInstance (line 30149) | buildInstance(options = {}) {
  method buildRegistry (line 30161) | buildRegistry() {
  method initializer (line 30171) | initializer(options) {
  method instanceInitializer (line 30179) | instanceInitializer(options) {
  method runInitializers (line 30187) | runInitializers() {
  method runInstanceInitializers (line 30200) | runInstanceInitializers(instance) {
  method _runInitializer (line 30208) | _runInitializer(bucketName, cb) {
  method buildRegistry (line 30422) | buildRegistry(namespace) {
  function resolverFor (line 30469) | function resolverFor(namespace) {
  function buildInitializerMethod (line 30475) | function buildInitializerMethod(bucketName, humanName) {
  function commonSetupRegistry (line 30495) | function commonSetupRegistry(registry) {
  method init (line 30563) | init() {
  method boot (line 30597) | boot(options) {
  method _bootSync (line 30619) | _bootSync(options) {
  method setupRegistry (line 30637) | setupRegistry(options = this.__container__.lookup('-environment:main')) {
  method unregister (line 30649) | unregister(fullName) {
  method buildChildEngineInstance (line 30664) | buildChildEngineInstance(name, options = {}) {
  method cloneParentDependencies (line 30683) | cloneParentDependencies() {
  method setupRegistry (line 30713) | setupRegistry(registry, options) {
  function getEngineParent (line 30756) | function getEngineParent(engine) {
  function setEngineParent (line 30768) | function setEngineParent(engine, parent) {
  function EmberError (line 30785) | function EmberError(message) {
  function populateListeners (line 30874) | function populateListeners(name) {
  function instrument (line 30894) | function instrument(name, p1, p2, p3) {
  function withFinalizer (line 30925) | function withFinalizer(callback, finalizer, payload, binding) {
  function NOOP (line 30937) | function NOOP() {}
  function _instrumentStart (line 30938) | function _instrumentStart(name, _payload, _payloadParam) {
  function subscribe (line 30992) | function subscribe(pattern, object) {
  function unsubscribe (line 31025) | function unsubscribe(subscriber) {
  function reset (line 31043) | function reset() {
  method constructor (line 31091) | constructor() {
  method create (line 31107) | static create() {
  method get (line 31119) | get(key) {
  method set (line 31139) | set(key, value) {
  method delete (line 31164) | delete(key) {
  method has (line 31190) | has(key) {
  method forEach (line 31205) | forEach(callback /*, ...thisArg*/) {
  method clear (line 31229) | clear() {
  method copy (line 31240) | copy() {
  method constructor (line 31274) | constructor() {
  method create (line 31283) | static create() {
  method clear (line 31292) | clear() {
  method add (line 31305) | add(obj, _guid) {
  method delete (line 31326) | delete(obj, _guid) {
  method isEmpty (line 31349) | isEmpty() {
  method has (line 31359) | has(obj) {
  method forEach (line 31376) | forEach(fn /*, ...thisArg*/) {
  method toArray (line 31401) | toArray() {
  method copy (line 31410) | copy() {
  method constructor (line 31423) | constructor() {
  method constructor (line 31486) | constructor(options) {
  method create (line 31506) | static create(options) {
  method get (line 31521) | get(key) {
  method copy (line 31538) | copy() {
  function expandPropertiesToArray (line 31773) | function expandPropertiesToArray(predicateName, properties) {
  function generateComputedWithPredicate (line 31790) | function generateComputedWithPredicate(name, predicate) {
  function empty (line 31845) | function empty(dependentKey) {
  function notEmpty (line 31880) | function notEmpty(dependentKey) {
  function none (line 31918) | function none(dependentKey) {
  function not (line 31953) | function not(dependentKey) {
  function bool (line 31990) | function bool(dependentKey) {
  function match (line 32029) | function match(dependentKey, regexp) {
  function equal (line 32068) | function equal(dependentKey, value) {
  function gt (line 32106) | function gt(dependentKey, value) {
  function gte (line 32144) | function gte(dependentKey, value) {
  function lt (line 32182) | function lt(dependentKey, value) {
  function lte (line 32220) | function lte(dependentKey, value) {
  function oneWay (line 32379) | function oneWay(dependentKey) {
  function readOnly (line 32435) | function readOnly(dependentKey) {
  function deprecatingAlias (line 32472) | function deprecatingAlias(dependentKey, options) {
  function reduceMacro (line 32507) | function reduceMacro(dependentKey, callback, initialValue, name) {
  function arrayMacro (line 32524) | function arrayMacro(dependentKey, callback) {
  function multiArrayMacro (line 32548) | function multiArrayMacro(_dependentKeys, callback, name) {
  function sum (line 32572) | function sum(dependentKey) {
  function max (line 32621) | function max(dependentKey) {
  function min (line 32670) | function min(dependentKey) {
  function map (line 32712) | function map(dependentKey, callback) {
  function mapBy (line 32752) | function mapBy(dependentKey, propertyKey) {
  function filter (line 32826) | function filter(dependentKey, callback) {
  function filterBy (line 32863) | function filterBy(dependentKey, propertyKey, value) {
  function uniq (line 32910) | function uniq(...args) {
  function uniqBy (line 32964) | function uniqBy(dependentKey, propertyKey) {
  function intersect (line 33045) | function intersect(...args) {
  function setDiff (line 33111) | function setDiff(setAProperty, setBProperty) {
  function collect (line 33165) | function collect(...dependentKeys) {
  function sort (line 33251) | function sort(itemsKey, sortDefinition) {
  function customSort (line 33261) | function customSort(itemsKey, comparator) {
  function propertySort (line 33269) | function propertySort(itemsKey, sortPropertiesKey) {
  function normalizeSortProperties (line 33328) | function normalizeSortProperties(sortProperties) {
  function sortByNormalizedSortProperties (line 33337) | function sortByNormalizedSortProperties(items, normalizedSortProperties) {
  function assign (line 33404) | function assign(target) {
  function merge (line 33450) | function merge(original, updates) {
  method constructor (line 33473) | constructor() {
  method add (line 33476) | add(val) {
  method delete (line 33480) | delete(val) {
  method has (line 33483) | has(val) {
  function getCurrentRunLoop (line 33510) | function getCurrentRunLoop() {
  function onBegin (line 33514) | function onBegin(current) {
  function onEnd (line 33518) | function onEnd(current, next) {
  function run (line 33599) | function run() {
  function join (line 33650) | function join() {
  function begin (line 33765) | function begin() {
  function end (line 33788) | function end() {
  function schedule (line 33828) | function schedule(queue /*, target, method */) {
  function hasScheduledTimers (line 33838) | function hasScheduledTimers() {
  function cancelTimers (line 33843) | function cancelTimers() {
  function later (line 33877) | function later() /*target, method*/{
  function once (line 33896) | function once(...args) {
  function scheduleOnce (line 33973) | function scheduleOnce(queue /*, target, method*/) {
  function next (line 34052) | function next(...args) {
  function cancel (line 34124) | function cancel(timer) {
  function debounce (line 34202) | function debounce() {
  function throttle (line 34249) | function throttle() {
  function inject (line 34296) | function inject(name, options) {
  function _fmt (line 34371) | function _fmt(str, formats) {
  function loc (line 34406) | function loc(str, formats) {
  function w (line 34435) | function w(str) {
  function decamelize (line 34453) | function decamelize(str) {
  function dasherize (line 34472) | function dasherize(str) {
  function camelize (line 34492) | function camelize(str) {
  function classify (line 34511) | function classify(str) {
  function underscore (line 34531) | function underscore(str) {
  function capitalize (line 34550) | function capitalize(str) {
  function setStrings (line 34688) | function setStrings(strings) {
  function getStrings (line 34691) | function getStrings() {
  function getString (line 34694) | function getString(name) {
  class InstructionEncoder (line 34701) | class InstructionEncoder {
    method constructor (line 34702) | constructor(buffer) {
    method encode (line 34707) | encode(type, machine) {
    method patch (line 34722) | patch(position, target) {
    method patchWith (line 34729) | patchWith(position, target, operand) {
  class Storage (line 34744) | class Storage {
    method constructor (line 34745) | constructor() {
    method add (line 34749) | add(element) {
    method deref (line 34760) | deref(pointer) {
    method drop (line 34763) | drop(pointer) {
  class Stack (line 34769) | class Stack {
    method constructor (line 34770) | constructor(vec = []) {
    method clone (line 34773) | clone() {
    method sliceFrom (line 34776) | sliceFrom(start) {
    method slice (line 34779) | slice(start, end) {
    method copy (line 34782) | copy(from, to) {
    method writeRaw (line 34786) | writeRaw(pos, value) {
    method writeSmi (line 34790) | writeSmi(pos, value) {
    method getRaw (line 34794) | getRaw(pos) {
    method getSmi (line 34797) | getSmi(pos) {
    method reset (line 34800) | reset() {
    method len (line 34803) | len() {
    method constructor (line 42087) | constructor() {
    method size (line 42091) | get size() {
    method push (line 42094) | push(item) {
    method pop (line 42098) | pop() {
    method isEmpty (line 42104) | isEmpty() {
  function decodeSmi (line 34807) | function decodeSmi(smi) {
  function encodeSmi (line 34817) | function encodeSmi(primitive) {
  class NodeDOMTreeConstruction (line 34834) | class NodeDOMTreeConstruction extends _runtime.DOMTreeConstruction {
    method constructor (line 34835) | constructor(doc) {
    method setupUselessElement (line 34839) | setupUselessElement() {}
    method insertHTMLBefore (line 34840) | insertHTMLBefore(parent, reference, html) {
    method createElement (line 34849) | createElement(tag) {
    method setAttribute (line 34853) | setAttribute(element, name, value) {
  function currentNode (line 34859) | function currentNode(cursor) {
  class SerializeBuilder (line 34867) | class SerializeBuilder extends _runtime.NewElementBuilder {
    method constructor (line 34868) | constructor() {
    method __openBlock (line 34872) | __openBlock() {
    method __closeBlock (line 34877) | __closeBlock() {
    method __appendHTML (line 34881) | __appendHTML(html) {
    method __appendText (line 34901) | __appendText(string) {
    method closeElement (line 34910) | closeElement() {
    method openElement (line 34917) | openElement(tag) {
    method pushRemoteElement (line 34931) | pushRemoteElement(element, cursorId, nextSibling = null) {
  function serializeBuilder (line 34939) | function serializeBuilder(env, cursor) {
  class Compilers (line 34965) | class Compilers {
    method constructor (line 34966) | constructor(offset = 0) {
    method add (line 34971) | add(name, func) {
    method compile (line 34975) | compile(sexp, builder) {
  function statementCompiler (line 34984) | function statementCompiler() {
  function dynamicAttr (line 35124) | function dynamicAttr(sexp, trusting, builder) {
  function expressionCompiler (line 35134) | function expressionCompiler() {
  class Macros (line 35207) | class Macros {
    method constructor (line 35208) | constructor() {
  class Blocks (line 35214) | class Blocks {
    method constructor (line 35215) | constructor() {
    method add (line 35219) | add(name, func) {
    method addMissing (line 35223) | addMissing(func) {
    method compile (line 35226) | compile(name, params, hash, template, inverse, builder) {
  class Inlines (line 35238) | class Inlines {
    method constructor (line 35239) | constructor() {
    method add (line 35243) | add(name, func) {
    method addMissing (line 35247) | addMissing(func) {
    method compile (line 35250) | compile(sexp, builder) {
  function populateBuiltins (line 35283) | function populateBuiltins(blocks = new Blocks(), inlines = new Inlines()) {
  class CompilableProgram (line 35498) | class CompilableProgram {
    method constructor (line 35499) | constructor(compiler, layout) {
    method symbolTable (line 35504) | get symbolTable() {
    method compile (line 35507) | compile() {
  class CompilableBlock (line 35514) | class CompilableBlock {
    method constructor (line 35515) | constructor(compiler, parsed) {
    method symbolTable (line 35520) | get symbolTable() {
    method compile (line 35523) | compile() {
  function compile (line 35535) | function compile(statements, builder, compiler) {
  function debugSlice (line 35544) | function debugSlice(program, start, end) {}
  function logOpcode (line 35545) | function logOpcode(type, params) {
  function json (line 35553) | function json(param) {}
  function debug (line 35554) | function debug(pos, c, op, ...operands) {
  function decodePrimitive (line 35605) | function decodePrimitive(primitive, constants) {
  class StdLib (line 35633) | class StdLib {
    method constructor (line 35634) | constructor(main, trustingGuardedAppend, cautiousGuardedAppend) {
    method compile (line 35639) | static compile(compiler) {
    method std (line 35645) | static std(compiler, callback) {
    method getAppend (line 35648) | getAppend(trusting) {
  class AbstractCompiler (line 35652) | class AbstractCompiler {
    method constructor (line 35653) | constructor(macros, program, resolver) {
    method initialize (line 35659) | initialize() {
    method constants (line 35662) | get constants() {
    method compileInline (line 35665) | compileInline(sexp, builder) {
    method compileBlock (line 35669) | compileBlock(name, params, hash, template, inverse, builder) {
    method add (line 35673) | add(statements, containingLayout) {
    method commit (line 35676) | commit(scopeSize, buffer) {
    method resolveLayoutForTag (line 35691) | resolveLayoutForTag(tag, referrer) {
    method resolveLayoutForHandle (line 35697) | resolveLayoutForHandle(handle) {
    method resolveModifier (line 35710) | resolveModifier(name, referrer) {
    method resolveHelper (line 35713) | resolveHelper(name, referrer) {
  class WrappedBuilder (line 35719) | class WrappedBuilder {
    method constructor (line 35720) | constructor(compiler, layout) {
    method compile (line 35738) | compile() {
  function blockFor (line 35797) | function blockFor(layout, compiler) {
  class ComponentBuilder (line 35806) | class ComponentBuilder {
    method constructor (line 35807) | constructor(builder) {
    method static (line 35810) | static(handle, args) {
  class Labels (line 35826) | class Labels {
    method constructor (line 35827) | constructor() {
    method label (line 35831) | label(name, index) {
    method target (line 35834) | target(at, target) {
    method patch (line 35837) | patch(encoder) {
  class StdOpcodeBuilder (line 35846) | class StdOpcodeBuilder {
    method constructor (line 35847) | constructor(compiler, size = 0) {
    method build (line 35853) | static build(compiler, callback) {
    method push (line 35858) | push(name) {
    method pushMachine (line 35870) | pushMachine(name) {
    method commit (line 35882) | commit() {
    method reserve (line 35886) | reserve(name) {
    method reserveWithOperand (line 35889) | reserveWithOperand(name, operand) {
    method reserveMachine (line 35892) | reserveMachine(name) {
    method main (line 35896) | main() {
    method appendHTML (line 35900) | appendHTML() {
    method appendSafeHTML (line 35903) | appendSafeHTML() {
    method appendDocumentFragment (line 35906) | appendDocumentFragment() {
    method appendNode (line 35909) | appendNode() {
    method appendText (line 35912) | appendText() {
    method beginComponentTransaction (line 35915) | beginComponentTransaction() {
    method commitComponentTransaction (line 35918) | commitComponentTransaction() {
    method pushDynamicScope (line 35921) | pushDynamicScope() {
    method popDynamicScope (line 35924) | popDynamicScope() {
    method pushRemoteElement (line 35927) | pushRemoteElement() {
    method popRemoteElement (line 35930) | popRemoteElement() {
    method pushRootScope (line 35933) | pushRootScope(symbols, bindCallerScope) {
    method pushVirtualRootScope (line 35936) | pushVirtualRootScope(register) {
    method pushChildScope (line 35939) | pushChildScope() {
    method popScope (line 35942) | popScope() {
    method prepareArgs (line 35945) | prepareArgs(state) {
    method createComponent (line 35948) | createComponent(state, hasDefault) {
    method registerComponentDestructor (line 35952) | registerComponentDestructor(state) {
    method putComponentOperations (line 35955) | putComponentOperations() {
    method getComponentSelf (line 35958) | getComponentSelf(state) {
    method getComponentTagName (line 35961) | getComponentTagName(state) {
    method getComponentLayout (line 35964) | getComponentLayout(state) {
    method setupForEval (line 35967) | setupForEval(state) {
    method invokeComponentLayout (line 35970) | invokeComponentLayout(state) {
    method didCreateElement (line 35973) | didCreateElement(state) {
    method didRenderLayout (line 35976) | didRenderLayout(state) {
    method pushFrame (line 35979) | pushFrame() {
    method popFrame (line 35982) | popFrame() {
    method pushSmallFrame (line 35985) | pushSmallFrame() {
    method popSmallFrame (line 35988) | popSmallFrame() {
    method invokeVirtual (line 35991) | invokeVirtual() {
    method invokeYield (line 35994) | invokeYield() {
    method toBoolean (line 35997) | toBoolean() {
    method invokePreparedComponent (line 36000) | invokePreparedComponent(hasBlock, bindableBlocks, bindableAtNames, pop...
    method pos (line 36024) | get pos() {
    method nextPos (line 36027) | get nextPos() {
    method compileInline (line 36031) | compileInline(sexp) {
    method compileBlock (line 36034) | compileBlock(name, params, hash, template, inverse) {
    method label (line 36037) | label(name) {
    method labels (line 36041) | get labels() {
    method startLabels (line 36044) | startLabels() {
    method stopLabels (line 36047) | stopLabels() {
    method pushCurriedComponent (line 36052) | pushCurriedComponent() {
    method pushDynamicComponentInstance (line 36055) | pushDynamicComponentInstance() {
    method openDynamicElement (line 36059) | openDynamicElement() {
    method flushElement (line 36062) | flushElement() {
    method closeElement (line 36065) | closeElement() {
    method putIterator (line 36069) | putIterator() {
    method enterList (line 36072) | enterList(start) {
    method exitList (line 36076) | exitList() {
    method iterate (line 36079) | iterate(breaks) {
    method setNamedVariables (line 36084) | setNamedVariables(state) {
    method setBlocks (line 36087) | setBlocks(state) {
    method setVariable (line 36090) | setVariable(symbol) {
    method setBlock (line 36093) | setBlock(symbol) {
    method getVariable (line 36096) | getVariable(symbol) {
    method getBlock (line 36099) | getBlock(symbol) {
    method hasBlock (line 36102) | hasBlock(symbol) {
    method concat (line 36105) | concat(size) {
    method load (line 36108) | load(register) {
    method fetch (line 36111) | fetch(register) {
    method dup (line 36114) | dup(register = _vm.Register.sp, offset = 0) {
    method pop (line 36117) | pop(count = 1) {
    method returnTo (line 36121) | returnTo(label) {
    method primitiveReference (line 36125) | primitiveReference() {
    method reifyU32 (line 36128) | reifyU32() {
    method enter (line 36131) | enter(args) {
    method exit (line 36134) | exit() {
    method return (line 36137) | return() {
    method jump (line 36140) | jump(target) {
    method jumpIf (line 36144) | jumpIf(target) {
    method jumpUnless (line 36148) | jumpUnless(target) {
    method jumpEq (line 36152) | jumpEq(value, target) {
    method assertSame (line 36156) | assertSame() {
    method pushEmptyArgs (line 36159) | pushEmptyArgs() {
    method switch (line 36162) | switch(_opcode, callback) {
    method stdAppend (line 36196) | stdAppend(trusting) {
    method populateLayout (line 36225) | populateLayout(state) {
    method invokeBareComponent (line 36228) | invokeBareComponent() {
    method isComponent (line 36241) | isComponent() {
    method contentType (line 36244) | contentType() {
    method pushBlockScope (line 36247) | pushBlockScope() {
  class OpcodeBuilder (line 36251) | class OpcodeBuilder extends StdOpcodeBuilder {
    method constructor (line 36252) | constructor(compiler, containingLayout) {
    method referrer (line 36262) | get referrer() {
    method setComponentAttrs (line 36265) | setComponentAttrs(enabled) {
    method expr (line 36268) | expr(expression) {
    method pushArgs (line 36277) | pushArgs(names, flags) {
    method pushYieldableBlock (line 36281) | pushYieldableBlock(block) {
    method curryComponent (line 36286) | curryComponent(definition,
    method pushSymbolTable (line 36297) | pushSymbolTable(table) {
    method invokeComponent (line 36305) | invokeComponent(capabilities, attrs, params, hash, synthetic, block, i...
    method invokeStaticComponent (line 36327) | invokeStaticComponent(capabilities, layout, attrs, params, hash, synth...
    method dynamicComponent (line 36417) | dynamicComponent(definition, attrs, params, hash, synthetic, block, in...
    method yield (line 36433) | yield(to, params) {
    method guardedAppend (line 36441) | guardedAppend(expression, trusting) {
    method invokeStaticBlock (line 36447) | invokeStaticBlock(block, callerCount = 0) {
    method string (line 36469) | string(_string) {
    method names (line 36472) | names(_names) {
    method symbols (line 36480) | symbols(symbols) {
    method primitive (line 36484) | primitive(_primitive) {
    method sizeImmediate (line 36524) | sizeImmediate(shifted, primitive) {
    method pushPrimitiveReference (line 36530) | pushPrimitiveReference(primitive) {
    method pushComponentDefinition (line 36535) | pushComponentDefinition(handle) {
    method resolveDynamicComponent (line 36538) | resolveDynamicComponent(referrer) {
    method staticComponentHelper (line 36541) | staticComponentHelper(tag, hash, template) {
    method invokePartial (line 36558) | invokePartial(referrer, symbols, evalInfo) {
    method resolveMaybeLocal (line 36564) | resolveMaybeLocal(name) {
    method debugger (line 36568) | debugger(symbols, evalInfo) {
    method text (line 36572) | text(text) {
    method openPrimitiveElement (line 36575) | openPrimitiveElement(tag) {
    method modifier (line 36578) | modifier(locator, params, hash) {
    method comment (line 36584) | comment(_comment) {
    method dynamicAttr (line 36588) | dynamicAttr(_name, _namespace, trusting) {
    method staticAttr (line 36597) | staticAttr(_name, _namespace, _value) {
    method hasBlockParams (line 36609) | hasBlockParams(to) {
    method getProperty (line 36614) | getProperty(key) {
    method helper (line 36617) | helper(helper, params, hash) {
    method bindDynamicScope (line 36624) | bindDynamicScope(_names) {
    method replayable (line 36689) | replayable({ args, body }) {
    method replayableIf (line 36747) | replayableIf({ args, ifTrue, ifFalse }) {
    method inlineBlock (line 36770) | inlineBlock(block) {
    method evalSymbols (line 36776) | evalSymbols() {
    method compileParams (line 36780) | compileParams(params) {
    method compileArgs (line 36787) | compileArgs(params, hash, blocks, synthetic) {
    method template (line 36809) | template(block) {
  class LazyOpcodeBuilder (line 36814) | class LazyOpcodeBuilder extends OpcodeBuilder {
    method pushBlock (line 36815) | pushBlock(block) {
    method resolveBlock (line 36822) | resolveBlock() {
    method pushLayout (line 36825) | pushLayout(layout) {
    method resolveLayout (line 36832) | resolveLayout() {
    method invokeStatic (line 36835) | invokeStatic(compilable) {
    method pushOther (line 36840) | pushOther(value) {
    method other (line 36843) | other(value) {
  class EagerOpcodeBuilder (line 36847) | class EagerOpcodeBuilder extends OpcodeBuilder {
    method pushBlock (line 36848) | pushBlock(block) {
    method resolveBlock (line 36852) | resolveBlock() {
    method pushLayout (line 36855) | pushLayout(layout) {
    method resolveLayout (line 36862) | resolveLayout() {}
    method invokeStatic (line 36863) | invokeStatic(compilable) {
  class LazyCompiler (line 36877) | class LazyCompiler extends AbstractCompiler {
    method constructor (line 36879) | constructor(lookup, resolver, macros) {
    method builderFor (line 36884) | builderFor(containingLayout) {
  class PartialDefinition (line 36889) | class PartialDefinition {
    method constructor (line 36890) | constructor(name, // for debugging
    method getPartial (line 36895) | getPartial() {
  function templateFactory (line 36903) | function templateFactory({ id: templateId, meta, block }) {
  class TemplateImpl (line 36915) | class TemplateImpl {
    method constructor (line 36916) | constructor(compiler, parsedLayout) {
    method asLayout (line 36928) | asLayout() {
    method asPartial (line 36932) | asPartial() {
    method asWrappedLayout (line 36936) | asWrappedLayout() {
  class WriteOnlyConstants (line 36971) | class WriteOnlyConstants {
    method constructor (line 36972) | constructor() {
    method string (line 36981) | string(value) {
    method stringArray (line 36988) | stringArray(strings) {
    method array (line 36995) | array(values) {
    method handle (line 37005) | handle(handle) {
    method serializable (line 37013) | serializable(value) {
    method number (line 37021) | number(number) {
    method toPool (line 37028) | toPool() {
  class RuntimeConstants (line 37037) | class RuntimeConstants {
    method constructor (line 37038) | constructor(resolver, pool) {
    method getString (line 37046) | getString(value) {
    method getNumber (line 37049) | getNumber(value) {
    method getStringArray (line 37052) | getStringArray(value) {
    method getArray (line 37061) | getArray(value) {
    method resolveHandle (line 37064) | resolveHandle(index) {
    method getSerializable (line 37072) | getSerializable(s) {
  class Constants (line 37076) | class Constants extends WriteOnlyConstants {
    method constructor (line 37077) | constructor(resolver, pool) {
    method getNumber (line 37088) | getNumber(value) {
    method getString (line 37091) | getString(value) {
    method getStringArray (line 37094) | getStringArray(value) {
    method getArray (line 37103) | getArray(value) {
    method resolveHandle (line 37106) | resolveHandle(index) {
    method getSerializable (line 37114) | getSerializable(s) {
  class LazyConstants (line 37118) | class LazyConstants extends Constants {
    method constructor (line 37119) | constructor() {
    method serializable (line 37124) | serializable(value) {
    method getSerializable (line 37131) | getSerializable(s) {
    method getOther (line 37134) | getOther(value) {
    method other (line 37137) | other(other) {
  class Opcode (line 37142) | class Opcode {
    method constructor (line 37143) | constructor(heap) {
    method size (line 37147) | get size() {
    method isMachine (line 37151) | get isMachine() {
    method type (line 37155) | get type() {
    method op1 (line 37158) | get op1() {
    method op2 (line 37161) | get op2() {
    method op3 (line 37164) | get op3() {
  function encodeTableInfo (line 37169) | function encodeTableInfo(size, scopeSize, state) {
  function changeState (line 37172) | function changeState(info, newState) {
  class Heap (line 37196) | class Heap {
    method constructor (line 37197) | constructor(serializedHeap) {
    method push (line 37214) | push(item) {
    method sizeCheck (line 37218) | sizeCheck() {
    method getbyaddr (line 37227) | getbyaddr(address) {
    method setbyaddr (line 37230) | setbyaddr(address, value) {
    method malloc (line 37233) | malloc() {
    method finishMalloc (line 37239) | finishMalloc(handle, scopeSize) {
    method size (line 37246) | size() {
    method getaddr (line 37252) | getaddr(handle) {
    method gethandle (line 37255) | gethandle(address) {
    method sizeof (line 37261) | sizeof(handle) {
    method scopesizeof (line 37264) | scopesizeof(handle) {
    method free (line 37268) | free(handle) {
    method compact (line 37279) | compact() {
    method pushPlaceholder (line 37306) | pushPlaceholder(valueFunc) {
    method patchPlaceholders (line 37312) | patchPlaceholders() {
    method capture (line 37320) | capture(offset = this.offset) {
  class WriteOnlyProgram (line 37331) | class WriteOnlyProgram {
    method constructor (line 37332) | constructor(constants = new WriteOnlyConstants(), heap = new Heap()) {
    method opcode (line 37337) | opcode(offset) {
  class RuntimeProgram (line 37342) | class RuntimeProgram {
    method constructor (line 37343) | constructor(constants, heap) {
    method hydrate (line 37348) | static hydrate(rawHeap, pool, resolver) {
    method opcode (line 37353) | opcode(offset) {
  class Program (line 37358) | class Program extends WriteOnlyProgram {}
  function slice (line 37359) | function slice(arr, start, end) {
  class RevisionTag (line 37390) | class RevisionTag {
    method validate (line 37391) | validate(snapshot) {
  class TagWrapper (line 37398) | class TagWrapper {
    method constructor (line 37399) | constructor(type, inner) {
    method value (line 37403) | value() {
    method validate (line 37407) | validate(snapshot) {
  function register (line 37412) | function register(Type) {
  function isConst (line 37431) | function isConst({ tag }) {
  function isConstTag (line 37434) | function isConstTag(tag) {
  function bump (line 37439) | function bump() {
  class DirtyableTag (line 37442) | class DirtyableTag extends RevisionTag {
    method create (line 37443) | static create(revision = $REVISION) {
    method constructor (line 37446) | constructor(revision = $REVISION) {
    method value (line 37450) | value() {
    method dirty (line 37453) | dirty() {
  function combineTagged (line 37458) | function combineTagged(tagged) {
  function combineSlice (line 37468) | function combineSlice(slice) {
  function combine (line 37479) | function combine(tags) {
  function _combine (line 37489) | function _combine(tags) {
  class CachedTag (line 37501) | class CachedTag extends RevisionTag {
    method constructor (line 37502) | constructor() {
    method value (line 37507) | value() {
    method invalidate (line 37515) | invalidate() {
  class TagsPair (line 37519) | class TagsPair extends CachedTag {
    method create (line 37520) | static create(first, second) {
    method constructor (line 37523) | constructor(first, second) {
    method compute (line 37528) | compute() {
  class TagsCombinator (line 37533) | class TagsCombinator extends CachedTag {
    method create (line 37534) | static create(tags) {
    method constructor (line 37537) | constructor(tags) {
    method compute (line 37541) | compute() {
  class UpdatableTag (line 37552) | class UpdatableTag extends CachedTag {
    method create (line 37553) | static create(tag) {
    method constructor (line 37556) | constructor(tag) {
    method compute (line 37561) | compute() {
    method update (line 37564) | update(tag) {
  class CachedReference (line 37573) | class CachedReference {
    method constructor (line 37574) | constructor() {
    method value (line 37578) | value() {
    method invalidate (line 37586) | invalidate() {
  class MapperReference (line 37590) | class MapperReference extends CachedReference {
    method constructor (line 37591) | constructor(reference, mapper) {
    method compute (line 37597) | compute() {
  function map (line 37602) | function map(reference, mapper) {
  class ReferenceCache (line 37606) | class ReferenceCache {
    method constructor (line 37607) | constructor(reference) {
    method peek (line 37614) | peek() {
    method revalidate (line 37620) | revalidate() {
    method initialize (line 37634) | initialize() {
  function isModified (line 37643) | function isModified(value) {
  class ConstReference (line 37647) | class ConstReference {
    method constructor (line 37648) | constructor(inner) {
    method value (line 37652) | value() {
  class ListItem (line 37657) | class ListItem extends _util.ListNode {
    method constructor (line 37658) | constructor(iterable, result) {
    method update (line 37666) | update(item) {
    method shouldRemove (line 37671) | shouldRemove() {
    method reset (line 37674) | reset() {
  class IterationArtifacts (line 37679) | class IterationArtifacts {
    method constructor (line 37680) | constructor(iterable) {
    method isEmpty (line 37687) | isEmpty() {
    method iterate (line 37691) | iterate() {
    method has (line 37701) | has(key) {
    method get (line 37704) | get(key) {
    method wasSeen (line 37707) | wasSeen(key) {
    method append (line 37711) | append(item) {
    method insertBefore (line 37717) | insertBefore(item, reference) {
    method move (line 37724) | move(item, reference) {
    method remove (line 37730) | remove(item) {
    method nextNode (line 37735) | nextNode(item) {
    method head (line 37738) | head() {
  class ReferenceIterator (line 37742) | class ReferenceIterator {
    method constructor (line 37745) | constructor(iterable) {
    method next (line 37750) | next() {
  class IteratorSynchronizer (line 37764) | class IteratorSynchronizer {
    method constructor (line 37765) | constructor({ target, artifacts }) {
    method sync (line 37771) | sync() {
    method advanceToKey (line 37787) | advanceToKey(key) {
    method nextAppend (line 37798) | nextAppend() {
    method nextRetain (line 37814) | nextRetain(item) {
    method nextMove (line 37821) | nextMove(item) {
    method nextInsert (line 37833) | nextInsert(item) {
    method startPrune (line 37838) | startPrune() {
    method nextPrune (line 37842) | nextPrune() {
    method nextDone (line 37857) | nextDone() {
  class AppendOpcodes (line 37897) | class AppendOpcodes {
    method constructor (line 37898) | constructor() {
    method add (line 37901) | add(name, evaluate, kind = 'syscall') {
    method debugBefore (line 37904) | debugBefore(vm, opcode, type) {
    method debugAfter (line 37910) | debugAfter(vm, opcode, type, pre) {
    method evaluate (line 37923) | evaluate(vm, opcode, type) {
  class AbstractOpcode (line 37935) | class AbstractOpcode {
    method constructor (line 37936) | constructor() {
  class UpdatingOpcode (line 37940) | class UpdatingOpcode extends AbstractOpcode {
    method constructor (line 37941) | constructor() {
  class PrimitiveReference (line 37948) | class PrimitiveReference extends _reference.ConstReference {
    method constructor (line 37949) | constructor(value) {
    method create (line 37952) | static create(value) {
    method get (line 37967) | get(_key) {
  class StringReference (line 37971) | class StringReference extends PrimitiveReference {
    method constructor (line 37972) | constructor() {
    method get (line 37976) | get(key) {
  class ValueReference (line 37988) | class ValueReference extends PrimitiveReference {
    method constructor (line 37989) | constructor(value) {
  class ConditionalReference (line 37997) | class ConditionalReference {
    method constructor (line 37998) | constructor(inner) {
    method value (line 38002) | value() {
    method toBool (line 38005) | toBool(value) {
  class ConcatReference (line 38010) | class ConcatReference extends _reference.CachedReference {
    method constructor (line 38011) | constructor(parts) {
    method compute (line 38016) | compute() {
  function castToString (line 38030) | function castToString(value) {
  function isCurriedComponentDefinition (line 38113) | function isCurriedComponentDefinition(definition) {
  function isComponentDefinition (line 38116) | function isComponentDefinition(definition) {
  class CurriedComponentDefinition (line 38119) | class CurriedComponentDefinition {
    method constructor (line 38121) | constructor(inner, args) {
    method unwrap (line 38126) | unwrap(args) {
    method offset (line 38142) | get offset() {
  function curry (line 38148) | function curry(spec, args = null) {
  function normalizeStringValue (line 38152) | function normalizeStringValue(value) {
  function shouldCoerce (line 38158) | function shouldCoerce(value) {
  function isEmpty (line 38161) | function isEmpty(value) {
  function isSafeString (line 38164) | function isSafeString(value) {
  function isNode (line 38167) | function isNode(value) {
  function isFragment (line 38170) | function isFragment(value) {
  function isString (line 38173) | function isString(value) {
  class DynamicTextContent (line 38177) | class DynamicTextContent extends UpdatingOpcode {
    method constructor (line 38178) | constructor(node, reference, lastValue) {
    method evaluate (line 38187) | evaluate() {
    method update (line 38194) | update(value) {
  class IsCurriedComponentDefinitionReference (line 38212) | class IsCurriedComponentDefinitionReference extends ConditionalReference {
    method create (line 38213) | static create(inner) {
    method toBool (line 38216) | toBool(value) {
  class ContentTypeReference (line 38220) | class ContentTypeReference {
    method constructor (line 38221) | constructor(inner) {
    method value (line 38225) | value() {
  class Assert (line 38427) | class Assert extends UpdatingOpcode {
    method constructor (line 38428) | constructor(cache) {
    method initialize (line 38434) | static initialize(cache) {
    method evaluate (line 38439) | evaluate(vm) {
  class JumpIfNotModifiedOpcode (line 38446) | class JumpIfNotModifiedOpcode extends UpdatingOpcode {
    method constructor (line 38447) | constructor(tag, target) {
    method evaluate (line 38454) | evaluate(vm) {
    method didModify (line 38460) | didModify() {
  class DidModifyOpcode (line 38464) | class DidModifyOpcode extends UpdatingOpcode {
    method constructor (line 38465) | constructor(target) {
    method evaluate (line 38471) | evaluate() {
  class LabelOpcode (line 38475) | class LabelOpcode {
    method constructor (line 38476) | constructor(label) {
    method evaluate (line 38485) | evaluate() {}
    method inspect (line 38486) | inspect() {
  class UpdateModifierOpcode (line 38558) | class UpdateModifierOpcode extends UpdatingOpcode {
    method constructor (line 38559) | constructor(tag, manager, modifier) {
    method evaluate (line 38567) | evaluate(vm) {
  class UpdateDynamicAttributeOpcode (line 38591) | class UpdateDynamicAttributeOpcode extends UpdatingOpcode {
    method constructor (line 38592) | constructor(reference, attribute) {
    method evaluate (line 38600) | evaluate(vm) {
  function resolveComponent (line 38609) | function resolveComponent(resolver, name, meta) {
  class CurryComponentReference (line 38615) | class CurryComponentReference {
    method constructor (line 38616) | constructor(inner, resolver, meta, args) {
    method value (line 38625) | value() {
    method get (line 38643) | get() {
    method curry (line 38646) | curry(definition) {
  class ClassListReference (line 38658) | class ClassListReference {
    method constructor (line 38659) | constructor(list) {
    method value (line 38664) | value() {
  function capabilityFlagsFrom (line 38678) | function capabilityFlagsFrom(capabilities) {
  function hasCapability (line 38681) | function hasCapability(capabilities, capability) {
  function resolveCurriedComponentDefinition (line 38818) | function resolveCurriedComponentDefinition(instance, definition, args) {
  class ComponentElementOperations (line 38870) | class ComponentElementOperations {
    method constructor (line 38871) | constructor() {
    method setAttribute (line 38875) | setAttribute(name, value, trusting, namespace) {
    method flush (line 38882) | flush(vm) {
  function hasStaticLayout (line 38942) | function hasStaticLayout(capabilities, _manager) {
  function hasDynamicLayout (line 38945) | function hasDynamicLayout(capabilities, _manager) {
  function bindBlock (line 38996) | function bindBlock(symbolName, blockName, state, blocks, vm) {
  class UpdateComponentOpcode (line 39027) | class UpdateComponentOpcode extends UpdatingOpcode {
    method constructor (line 39028) | constructor(tag, component, manager, dynamicScope) {
    method evaluate (line 39036) | evaluate(_vm) {
  class DidUpdateLayoutOpcode (line 39041) | class DidUpdateLayoutOpcode extends UpdatingOpcode {
    method constructor (line 39042) | constructor(manager, component, bounds) {
    method evaluate (line 39050) | evaluate(vm) {
  function debugCallback (line 39058) | function debugCallback(context, get) {
  function setDebuggerCallback (line 39067) | function setDebuggerCallback(cb) {
  function resetDebuggerCallback (line 39070) | function resetDebuggerCallback() {
  class ScopeInspector (line 39073) | class ScopeInspector {
    method constructor (line 39074) | constructor(scope, symbols, evalInfo) {
    method get (line 39084) | get(path) {
  class IterablePresenceReference (line 39150) | class IterablePresenceReference {
    method constructor (line 39151) | constructor(artifacts) {
    method value (line 39155) | value() {
  class Cursor (line 39185) | class Cursor {
    method constructor (line 39186) | constructor(element, nextSibling) {
  class ConcreteBounds (line 39191) | class ConcreteBounds {
    method constructor (line 39192) | constructor(parentNode, first, last) {
    method parentElement (line 39197) | parentElement() {
    method firstNode (line 39200) | firstNode() {
    method lastNode (line 39203) | lastNode() {
  class SingleNodeBounds (line 39207) | class SingleNodeBounds {
    method constructor (line 39208) | constructor(parentNode, node) {
    method parentElement (line 39212) | parentElement() {
    method firstNode (line 39215) | firstNode() {
    method lastNode (line 39218) | lastNode() {
  function bounds (line 39222) | function bounds(parent, first, last) {
  function single (line 39225) | function single(parent, node) {
  function move (line 39228) | function move(bounds, reference) {
  function clear (line 39241) | function clear(bounds) {
  function applySVGInnerHTMLFix (line 39267) | function applySVGInnerHTMLFix(document, DOMClass, svgNamespace) {
  function fixSVG (line 39282) | function fixSVG(parent, div, html, reference) {
  function shouldApplyFix (line 39302) | function shouldApplyFix(document, svgNamespace) {
  function applyTextNodeMergingFix (line 39331) | function applyTextNodeMergingFix(document, DOMClass) {
  function shouldApplyFix$1 (line 39356) | function shouldApplyFix$1(document) {
  function isWhitespace (line 39379) | function isWhitespace(string) {
  function moveNodesBefore (line 39382) | function moveNodesBefore(source, target, nextSibling) {
  class DOMOperations (line 39393) | class DOMOperations {
    method constructor (line 39394) | constructor(document) {
    method setupUselessElement (line 39400) | setupUselessElement() {
    method createElement (line 39403) | createElement(tag, context) {
    method insertBefore (line 39424) | insertBefore(parent, node, reference) {
    method insertHTMLBefore (line 39427) | insertHTMLBefore(_parent, nextSibling, html) {
    method createTextNode (line 39430) | createTextNode(text) {
    method createComment (line 39433) | createComment(data) {
  class TreeConstruction (line 39439) | class TreeConstruction extends DOMOperations {
    method createElementNS (line 39440) | createElementNS(namespace, tag) {
    method setAttribute (line 39443) | setAttribute(element, name, value, namespace = null) {
  class DOMChanges (line 39457) | class DOMChanges extends DOMOperations {
    method constructor (line 39458) | constructor(document) {
    method setAttribute (line 39463) | setAttribute(element, name, value) {
    method removeAttribute (line 39466) | removeAttribute(element, name) {
    method insertAfter (line 39469) | insertAfter(element, node, reference) {
  function insertHTMLBefore (line 39473) | function insertHTMLBefore(useless, _parent, _nextSibling, _html) {
  function has (line 39510) | function has(array, item) {
  function checkURI (line 39513) | function checkURI(tagName, attribute) {
  function checkDataURI (line 39516) | function checkDataURI(tagName, attribute) {
  function requiresSanitization (line 39520) | function requiresSanitization(tagName, attribute) {
  function sanitizeAttributeValue (line 39523) | function sanitizeAttributeValue(env, element, attribute, value) {
  function normalizeProperty (line 39555) | function normalizeProperty(element, slotName) {
  function preferAttr (line 39600) | function preferAttr(tagName, propName) {
  function dynamicAttribute (line 39605) | function dynamicAttribute(element, attr, namespace) {
  function buildDynamicAttribute (line 39618) | function buildDynamicAttribute(tagName, name, attribute) {
  function buildDynamicProperty (line 39625) | function buildDynamicProperty(tagName, name, attribute) {
  class DynamicAttribute (line 39637) | class DynamicAttribute {
    method constructor (line 39638) | constructor(attribute) {
  class SimpleDynamicAttribute (line 39642) | class SimpleDynamicAttribute extends DynamicAttribute {
    method set (line 39643) | set(dom, value, _env) {
    method update (line 39650) | update(value, _env) {
  class DefaultDynamicProperty (line 39660) | class DefaultDynamicProperty extends DynamicAttribute {
    method constructor (line 39661) | constructor(normalizedName, attribute) {
    method set (line 39665) | set(dom, value, _env) {
    method update (line 39671) | update(value, _env) {
    method removeAttribute (line 39680) | removeAttribute() {
  class SafeDynamicProperty (line 39691) | class SafeDynamicProperty extends DefaultDynamicProperty {
    method set (line 39692) | set(dom, value, env) {
    method update (line 39697) | update(value, env) {
  class SafeDynamicAttribute (line 39703) | class SafeDynamicAttribute extends SimpleDynamicAttribute {
    method set (line 39704) | set(dom, value, env) {
    method update (line 39709) | update(value, env) {
  class InputValueDynamicAttribute (line 39715) | class InputValueDynamicAttribute extends DefaultDynamicProperty {
    method set (line 39716) | set(dom, value) {
    method update (line 39719) | update(value) {
  class OptionSelectedDynamicAttribute (line 39728) | class OptionSelectedDynamicAttribute extends DefaultDynamicProperty {
    method set (line 39729) | set(dom, value) {
    method update (line 39734) | update(value) {
  function isOptionSelected (line 39743) | function isOptionSelected(tagName, attribute) {
  function isUserInputValue (line 39746) | function isUserInputValue(tagName, attribute) {
  function normalizeValue (line 39749) | function normalizeValue(value) {
  class Scope (line 39763) | class Scope {
    method constructor (line 39764) | constructor(
    method root (line 39776) | static root(self, size = 0) {
    method sized (line 39783) | static sized(size = 0) {
    method init (line 39790) | init({ self }) {
    method getSelf (line 39794) | getSelf() {
    method getSymbol (line 39797) | getSymbol(symbol) {
    method getBlock (line 39800) | getBlock(symbol) {
    method getEvalScope (line 39804) | getEvalScope() {
    method getPartialMap (line 39807) | getPartialMap() {
    method bind (line 39810) | bind(symbol, value) {
    method bindSelf (line 39813) | bindSelf(self) {
    method bindSymbol (line 39816) | bindSymbol(symbol, value) {
    method bindBlock (line 39819) | bindBlock(symbol, value) {
    method bindEvalScope (line 39822) | bindEvalScope(map) {
    method bindPartialMap (line 39825) | bindPartialMap(map) {
    method bindCallerScope (line 39828) | bindCallerScope(scope) {
    method getCallerScope (line 39831) | getCallerScope() {
    method child (line 39834) | child() {
    method get (line 39837) | get(index) {
    method set (line 39843) | set(index, value) {
  class Transaction (line 39850) | class Transaction {
    method constructor (line 39851) | constructor() {
    method didCreate (line 39862) | didCreate(component, manager) {
    method didUpdate (line 39866) | didUpdate(component, manager) {
    method scheduleInstallModifier (line 39870) | scheduleInstallModifier(modifier, manager) {
    method scheduleUpdateModifier (line 39874) | scheduleUpdateModifier(modifier, manager) {
    method didDestroy (line 39878) | didDestroy(d) {
    method commit (line 39881) | commit() {
  class Environment (line 39912) | class Environment {
    method constructor (line 39913) | constructor({ appendOperations, updateOperations }) {
    method toConditionalReference (line 39918) | toConditionalReference(reference) {
    method getAppendOperations (line 39921) | getAppendOperations() {
    method getDOM (line 39924) | getDOM() {
    method begin (line 39927) | begin() {
    method transaction (line 39931) | get transaction() {
    method didCreate (line 39934) | didCreate(component, manager) {
    method didUpdate (line 39937) | didUpdate(component, manager) {
    method scheduleInstallModifier (line 39940) | scheduleInstallModifier(modifier, manager) {
    method scheduleUpdateModifier (line 39943) | scheduleUpdateModifier(modifier, manager) {
    method didDestroy (line 39946) | didDestroy(d) {
    method commit (line 39949) | commit() {
    method attributeFor (line 39954) | attributeFor(element, attr, _isTrusting, namespace = null) {
  class DefaultEnvironment (line 39958) | class DefaultEnvironment extends Environment {
    method constructor (line 39959) | constructor(options) {
  class LowLevelVM (line 39970) | class LowLevelVM {
    method constructor (line 39971) | constructor(stack, heap, program, externs, pc = -1, ra = -1) {
    method pushFrame (line 39981) | pushFrame() {
    method popFrame (line 39987) | popFrame() {
    method pushSmallFrame (line 39992) | pushSmallFrame() {
    method popSmallFrame (line 39995) | popSmallFrame() {
    method goto (line 39999) | goto(offset) {
    method call (line 40004) | call(handle) {
    method returnTo (line 40009) | returnTo(offset) {
    method return (line 40014) | return() {
    method nextStatement (line 40017) | nextStatement() {
    method evaluateOuter (line 40032) | evaluateOuter(opcode, vm) {
    method evaluateInner (line 40037) | evaluateInner(opcode, vm) {
    method evaluateMachine (line 40044) | evaluateMachine(opcode) {
    method evaluateSyscall (line 40066) | evaluateSyscall(opcode, vm) {
  class First (line 40071) | class First {
    method constructor (line 40072) | constructor(node) {
    method firstNode (line 40075) | firstNode() {
  class Last (line 40079) | class Last {
    method constructor (line 40080) | constructor(node) {
    method lastNode (line 40083) | lastNode() {
  class NewElementBuilder (line 40087) | class NewElementBuilder {
    method constructor (line 40088) | constructor(env, parentNode, nextSibling) {
    method forInitialRender (line 40098) | static forInitialRender(env, cursor) {
    method resume (line 40103) | static resume(env, tracker, nextSibling) {
    method element (line 40110) | get element() {
    method nextSibling (line 40113) | get nextSibling() {
    method expectConstructing (line 40116) | expectConstructing(method) {
    method block (line 40119) | block() {
    method popElement (line 40122) | popElement() {
    method pushSimpleBlock (line 40126) | pushSimpleBlock() {
    method pushUpdatableBlock (line 40129) | pushUpdatableBlock() {
    method pushBlockList (line 40132) | pushBlockList(list) {
    method pushBlockTracker (line 40135) | pushBlockTracker(tracker, isRemote = false) {
    method popBlock (line 40147) | popBlock() {
    method __openBlock (line 40152) | __openBlock() {}
    method __closeBlock (line 40153) | __closeBlock() {}
    method openElement (line 40155) | openElement(tag) {
    method __openElement (line 40160) | __openElement(tag) {
    method flushElement (line 40163) | flushElement() {
    method __flushElement (line 40172) | __flushElement(parent, constructing) {
    method closeElement (line 40175) | closeElement() {
    method pushRemoteElement (line 40179) | pushRemoteElement(element, guid, nextSibling = null) {
    method __pushRemoteElement (line 40182) | __pushRemoteElement(element, _guid, nextSibling) {
    method popRemoteElement (line 40187) | popRemoteElement() {
    method pushElement (line 40191) | pushElement(element, nextSibling) {
    method didAddDestroyable (line 40194) | didAddDestroyable(d) {
    method didAppendBounds (line 40197) | didAppendBounds(bounds$$1) {
    method didAppendNode (line 40201) | didAppendNode(node) {
    method didOpenElement (line 40205) | didOpenElement(element) {
    method willCloseElement (line 40209) | willCloseElement() {
    method appendText (line 40212) | appendText(string) {
    method __appendText (line 40215) | __appendText(text) {
    method __appendNode (line 40221) | __appendNode(node) {
    method __appendFragment (line 40225) | __appendFragment(fragment) {
    method __appendHTML (line 40235) | __appendHTML(html) {
    method appendDynamicHTML (line 40238) | appendDynamicHTML(value) {
    method appendDynamicText (line 40242) | appendDynamicText(value) {
    method appendDynamicFragment (line 40247) | appendDynamicFragment(value) {
    method appendDynamicNode (line 40251) | appendDynamicNode(value) {
    method trustedContent (line 40256) | trustedContent(value) {
    method untrustedContent (line 40259) | untrustedContent(value) {
    method appendComment (line 40262) | appendComment(string) {
    method __appendComment (line 40265) | __appendComment(string) {
    method __setAttribute (line 40271) | __setAttribute(name, value, namespace) {
    method __setProperty (line 40274) | __setProperty(name, value) {
    method setStaticAttribute (line 40277) | setStaticAttribute(name, value, namespace) {
    method setDynamicAttribute (line 40280) | setDynamicAttribute(name, value, trusting, namespace) {
  class SimpleBlockTracker (line 40287) | class SimpleBlockTracker {
    method constructor (line 40288) | constructor(parent) {
    method destroy (line 40295) | destroy() {
    method parentElement (line 40303) | parentElement() {
    method firstNode (line 40306) | firstNode() {
    method lastNode (line 40309) | lastNode() {
    method openElement (line 40312) | openElement(element) {
    method closeElement (line 40316) | closeElement() {
    method didAppendNode (line 40319) | didAppendNode(node) {
    method didAppendBounds (line 40326) | didAppendBounds(bounds$$1) {
    method newDestroyable (line 40333) | newDestroyable(d) {
    method finalize (line 40337) | finalize(stack) {
  class RemoteBlockTracker (line 40343) | class RemoteBlockTracker extends SimpleBlockTracker {
    method destroy (line 40344) | destroy() {
  class UpdatableBlockTracker (line 40349) | class UpdatableBlockTracker extends SimpleBlockTracker {
    method reset (line 40350) | reset(env) {
  class BlockListTracker (line 40365) | class BlockListTracker {
    method constructor (line 40366) | constructor(parent, boundList) {
    method destroy (line 40372) | destroy() {
    method parentElement (line 40375) | parentElement() {
    method firstNode (line 40378) | firstNode() {
    method lastNode (line 40382) | lastNode() {
    method openElement (line 40386) | openElement(_element) {}
    method closeElement (line 40387) | closeElement() {}
    method didAppendNode (line 40388) | didAppendNode(_node) {}
    method didAppendBounds (line 40389) | didAppendBounds(_bounds) {}
    method newDestroyable (line 40390) | newDestroyable(_d) {}
    method finalize (line 40391) | finalize(_stack) {}
  function clientBuilder (line 40393) | function clientBuilder(env, cursor) {
  class InnerStack (line 40399) | class InnerStack {
    method constructor (line 40400) | constructor(inner = new _lowLevel.Stack(), js = []) {
    method slice (line 40404) | slice(start, end) {
    method sliceInner (line 40415) | sliceInner(start, end) {
    method copy (line 40422) | copy(from, to) {
    method write (line 40425) | write(pos, value) {
    method writeSmi (line 40434) | writeSmi(pos, value) {
    method writeImmediate (line 40437) | writeImmediate(pos, value) {
    method get (line 40440) | get(pos) {
    method getSmi (line 40448) | getSmi(pos) {
    method reset (line 40451) | reset() {
    method length (line 40455) | get length() {
  class EvaluationStack (line 40459) | class EvaluationStack {
    method constructor (line 40460) | constructor(stack, fp, sp) {
    method empty (line 40465) | static empty() {
    method restore (line 40468) | static restore(snapshot) {
    method push (line 40475) | push(value) {
    method pushSmi (line 40478) | pushSmi(value) {
    method pushImmediate (line 40481) | pushImmediate(value) {
    method pushEncodedImmediate (line 40484) | pushEncodedImmediate(value) {
    method pushNull (line 40487) | pushNull() {
    method dup (line 40490) | dup(position = this.sp) {
    method copy (line 40493) | copy(from, to) {
    method pop (line 40496) | pop(n = 1) {
    method popSmi (line 40501) | popSmi() {
    method peek (line 40504) | peek(offset = 0) {
    method peekSmi (line 40507) | peekSmi(offset = 0) {
    method get (line 40510) | get(offset, base = this.fp) {
    method getSmi (line 40513) | getSmi(offset, base = this.fp) {
    method set (line 40516) | set(value, offset, base = this.fp) {
    method slice (line 40519) | slice(start, end) {
    method sliceArray (line 40522) | sliceArray(start, end) {
    method capture (line 40525) | capture(items) {
    method reset (line 40530) | reset() {
    method toArray (line 40533) | toArray() {
  function isImmediate (line 40537) | function isImmediate(value) {
  function encodeSmi (line 40555) | function encodeSmi(primitive) {
  function encodeImmediate (line 40562) | function encodeImmediate(primitive) {
  function decodeSmi (line 40577) | function decodeSmi(smi) {
  function decodeImmediate (line 40587) | function decodeImmediate(immediate) {
  class UpdatingVM (line 40602) | class UpdatingVM {
    method constructor (line 40603) | constructor(env, program, { alwaysRevalidate = false }) {
    method execute (line 40610) | execute(opcodes, handler) {
    method frame (line 40623) | get frame() {
    method goto (line 40626) | goto(op) {
    method try (line 40629) | try(ops, handler) {
    method throw (line 40632) | throw() {
  class BlockOpcode (line 40637) | class BlockOpcode extends UpdatingOpcode {
    method constructor (line 40638) | constructor(start, state, runtime, bounds$$1, children) {
    method parentElement (line 40649) | parentElement() {
    method firstNode (line 40652) | firstNode() {
    method lastNode (line 40655) | lastNode() {
    method evaluate (line 40658) | evaluate(vm) {
    method destroy (line 40661) | destroy() {
    method didDestroy (line 40664) | didDestroy() {
  class TryOpcode (line 40668) | class TryOpcode extends BlockOpcode {
    method constructor (line 40669) | constructor(start, state, runtime, bounds$$1, children) {
    method didInitializeChildren (line 40674) | didInitializeChildren() {
    method evaluate (line 40677) | evaluate(vm) {
    method handleException (line 40680) | handleException() {
  class ListRevalidationDelegate (line 40696) | class ListRevalidationDelegate {
    method constructor (line 40697) | constructor(opcode, marker) {
    method insert (line 40705) | insert(key, item, memo, before) {
    method retain (line 40727) | retain(_key, _item, _memo) {}
    method move (line 40728) | move(key, _item, _memo, before) {
    method delete (line 40740) | delete(key) {
    method done (line 40749) | done() {
  class ListBlockOpcode (line 40753) | class ListBlockOpcode extends BlockOpcode {
    method constructor (line 40754) | constructor(start, state, runtime, bounds$$1, children, artifacts) {
    method didInitializeChildren (line 40763) | didInitializeChildren(listDidChange = true) {
    method evaluate (line 40769) | evaluate(vm) {
    method vmForInsertion (line 40784) | vmForInsertion(nextSibling) {
  class UpdatingVMFrame (line 40793) | class UpdatingVMFrame {
    method constructor (line 40794) | constructor(ops, exceptionHandler) {
    method goto (line 40799) | goto(op) {
    method nextStatement (line 40802) | nextStatement() {
    method handleException (line 40807) | handleException() {
  class RenderResult (line 40814) | class RenderResult {
    method constructor (line 40815) | constructor(env, program, updating, bounds$$1) {
    method rerender (line 40821) | rerender({ alwaysRevalidate = false } = { alwaysRevalidate: false }) {
    method parentElement (line 40826) | parentElement() {
    method firstNode (line 40829) | firstNode() {
    method lastNode (line 40832) | lastNode() {
    method handleException (line 40835) | handleException() {
    method destroy (line 40838) | destroy() {
  class Arguments (line 40844) | class Arguments {
    method constructor (line 40845) | constructor() {
    method empty (line 40851) | empty(stack) {
    method setup (line 40858) | setup(stack, names, blockNames, positionalCount, synthetic) {
    method tag (line 40879) | get tag() {
    method base (line 40882) | get base() {
    method length (line 40885) | get length() {
    method at (line 40888) | at(pos) {
    method realloc (line 40891) | realloc(offset) {
    method capture (line 40905) | capture() {
    method clear (line 40915) | clear() {
  class PositionalArguments (line 40920) | class PositionalArguments {
    method constructor (line 40921) | constructor() {
    method empty (line 40928) | empty(stack, base) {
    method setup (line 40935) | setup(stack, base, length) {
    method tag (line 40947) | get tag() {
    method at (line 40954) | at(position) {
    method capture (line 40961) | capture() {
    method prepend (line 40964) | prepend(other) {
    method references (line 40977) | get references() {
  class CapturedPositionalArguments (line 40986) | class CapturedPositionalArguments {
    method constructor (line 40987) | constructor(tag, references, length = references.length) {
    method empty (line 40992) | static empty() {
    method at (line 40995) | at(position) {
    method value (line 40998) | value() {
    method get (line 41001) | get(name) {
    method valueOf (line 41014) | valueOf(reference) {
  class NamedArguments (line 41018) | class NamedArguments {
    method constructor (line 41019) | constructor() {
    method empty (line 41026) | empty(stack, base) {
    method setup (line 41034) | setup(stack, base, length, names, synthetic) {
    method tag (line 41053) | get tag() {
    method names (line 41056) | get names() {
    method atNames (line 41063) | get atNames() {
    method has (line 41070) | has(name) {
    method get (line 41073) | get(name, synthetic = true) {
    method capture (line 41082) | capture() {
    method merge (line 41085) | merge(other) {
    method references (line 41107) | get references() {
    method toSyntheticName (line 41115) | toSyntheticName(name) {
    method toAtName (line 41118) | toAtName(name) {
  class CapturedNamedArguments (line 41122) | class CapturedNamedArguments {
    method constructor (line 41123) | constructor(tag, names, references) {
    method map (line 41130) | get map() {
    method has (line 41142) | has(name) {
    method get (line 41145) | get(name) {
    method value (line 41154) | value() {
  class BlockArguments (line 41164) | class BlockArguments {
    method constructor (line 41165) | constructor() {
    method empty (line 41172) | empty(stack, base) {
    method setup (line 41180) | setup(stack, base, length, names) {
    method values (line 41193) | get values() {
    method has (line 41201) | has(name) {
    method get (line 41204) | get(name) {
    method capture (line 41215) | capture() {
  class CapturedBlockArguments (line 41219) | class CapturedBlockArguments {
    method constructor (line 41220) | constructor(names, values) {
    method has (line 41225) | has(name) {
    method get (line 41228) | get(name) {
  class VM (line 41243) | class VM {
    method constructor (line 41244) | constructor(runtime, scope, dynamicScope, elementStack) {
    method stack (line 41272) | get stack() {
    method stack (line 41275) | set stack(value) {
    method currentOpSize (line 41279) | set currentOpSize(value) {
    method currentOpSize (line 41282) | get currentOpSize() {
    method pc (line 41285) | get pc() {
    method pc (line 41288) | set pc(value) {
    method ra (line 41292) | get ra() {
    method ra (line 41295) | set ra(value) {
    method fp (line 41298) | get fp() {
    method fp (line 41301) | set fp(fp) {
    method sp (line 41304) | get sp() {
    method sp (line 41307) | set sp(sp) {
    method fetch (line 41311) | fetch(register) {
    method load (line 41315) | load(register) {
    method fetchValue (line 41319) | fetchValue(register) {
    method loadValue (line 41323) | loadValue(register, value) {
    method pushFrame (line 41330) | pushFrame() {
    method popFrame (line 41334) | popFrame() {
    method goto (line 41338) | goto(offset) {
    method call (line 41342) | call(handle) {
    method returnTo (line 41346) | returnTo(offset) {
    method return (line 41350) | return() {
    method initial (line 41356) | static initial(program, env, self, dynamicScope, elementStack, handle) {
    method empty (line 41364) | static empty(program, env, elementStack) {
    method resume (line 41380) | static resume({ scope, dynamicScope }, runtime, stack) {
    method program (line 41383) | get program() {
    method env (line 41386) | get env() {
    method capture (line 41389) | capture(args) {
    method beginCacheGroup (line 41396) | beginCacheGroup() {
    method commitCacheGroup (line 41399) | commitCacheGroup() {
    method enter (line 41417) | enter(args) {
    method iterate (line 41424) | iterate(memo, value) {
    method enterItem (line 41435) | enterItem(key, opcode) {
    method enterList (line 41439) | enterList(relativeStart) {
    method didEnter (line 41450) | didEnter(opcode) {
    method exit (line 41454) | exit() {
    method exitList (line 41460) | exitList() {
    method updateWith (line 41464) | updateWith(opcode) {
    method listBlock (line 41467) | listBlock() {
    method updating (line 41470) | updating() {
    method elements (line 41473) | elements() {
    method scope (line 41476) | scope() {
    method dynamicScope (line 41479) | dynamicScope() {
    method pushChildScope (line 41482) | pushChildScope() {
    method pushDynamicScope (line 41485) | pushDynamicScope() {
    method pushRootScope (line 41490) | pushRootScope(size, bindCaller) {
    method pushScope (line 41496) | pushScope(scope) {
    method popScope (line 41499) | popScope() {
    method popDynamicScope (line 41502) | popDynamicScope() {
    method newDestroyable (line 41505) | newDestroyable(d) {
    method getSelf (line 41509) | getSelf() {
    method referenceForSymbol (line 41512) | referenceForSymbol(symbol) {
    method execute (line 41516) | execute(start, initialize) {
    method next (line 41526) | next() {
    method bindDynamicScope (line 41543) | bindDynamicScope(names) {
  class TemplateIteratorImpl (line 41552) | class TemplateIteratorImpl {
    method constructor (line 41553) | constructor(vm) {
    method next (line 41556) | next() {
  function render (line 41560) | function render(program, env, self, dynamicScope, builder, handle) {
  class DynamicVarReference (line 41565) | class DynamicVarReference {
    method constructor (line 41566) | constructor(scope, nameRef) {
    method value (line 41572) | value() {
    method get (line 41575) | get(key) {
    method getVar (line 41578) | getVar() {
  function getDynamicVar (line 41585) | function getDynamicVar(vm, args) {
  class RehydratingCursor (line 41617) | class RehydratingCursor extends Cursor {
    method constructor (line 41618) | constructor(element, nextSibling, startingBlockDepth) {
  class RehydrateBuilder (line 41626) | class RehydrateBuilder extends NewElementBuilder {
    method constructor (line 41628) | constructor(env, parentNode, nextSibling) {
    method currentCursor (line 41643) | get currentCursor() {
    method candidate (line 41646) | get candidate() {
    method candidate (line 41652) | set candidate(node) {
    method pushElement (line 41655) | pushElement(element, nextSibling) {
    method clearMismatch (line 41679) | clearMismatch(candidate) {
    method __openBlock (line 41700) | __openBlock() {
    method __closeBlock (line 41714) | __closeBlock() {
    method __appendNode (line 41740) | __appendNode(node) {
    method __appendHTML (line 41751) | __appendHTML(html) {
    method remove (line 41770) | remove(node) {
    method markerBounds (line 41776) | markerBounds() {
    method __appendText (line 41789) | __appendText(string) {
    method __appendComment (line 41816) | __appendComment(string) {
    method __openElement (line 41829) | __openElement(tag) {
    method __setAttribute (line 41844) | __setAttribute(name, value, namespace) {
    method __setProperty (line 41858) | __setProperty(name, value) {
    method __flushElement (line 41872) | __flushElement(parent, constructing) {
    method willCloseElement (line 41883) | willCloseElement() {
    method getMarker (line 41893) | getMarker(element, guid) {
    method __pushRemoteElement (line 41900) | __pushRemoteElement(element, cursorId, nextSibling = null) {
    method didAppendBounds (line 41912) | didAppendBounds(bounds$$1) {
  function isTextNode (line 41921) | function isTextNode(node) {
  function isComment (line 41924) | function isComment(node) {
  function getOpenBlockDepth (line 41927) | function getOpenBlockDepth(node) {
  function getCloseBlockDepth (line 41935) | function getCloseBlockDepth(node) {
  function isElement (line 41943) | function isElement(node) {
  function isMarker (line 41946) | function isMarker(node) {
  function isSeparator (line 41949) | function isSeparator(node) {
  function isEmpty$1 (line 41952) | function isEmpty$1(node) {
  function isSameNodeType (line 41955) | function isSameNodeType(candidate, tag) {
  function findByName (line 41961) | function findByName(array, name) {
  function rehydrationBuilder (line 41968) | function rehydrationBuilder(env, cursor) {
  function unwrap (line 42013) | function unwrap(val) {
  function expect (line 42017) | function expect(val, message) {
  function unreachable (line 42021) | function unreachable(message = 'unreachable') {
  function debugAssert (line 42027) | function debugAssert(test, msg) {
  function assign (line 42038) | function assign(obj) {
  function fillNulls (line 42050) | function fillNulls(count) {
  function initializeGuid (line 42059) | function initializeGuid(object) {
  function ensureGuid (line 42062) | function ensureGuid(object) {
  function isSerializationFirstNode (line 42067) | function isSerializationFirstNode(node) {
  function dict (line 42071) | function dict() {
  class DictSet (line 42074) | class DictSet {
    method constructor (line 42075) | constructor() {
    method add (line 42078) | add(obj) {
    method delete (line 42082) | delete(obj) {
  class Stack (line 42086) | class Stack {
    method constructor (line 34770) | constructor(vec = []) {
    method clone (line 34773) | clone() {
    method sliceFrom (line 34776) | sliceFrom(start) {
    method slice (line 34779) | slice(start, end) {
    method copy (line 34782) | copy(from, to) {
    method writeRaw (line 34786) | writeRaw(pos, value) {
    method writeSmi (line 34790) | writeSmi(pos, value) {
    method getRaw (line 34794) | getRaw(pos) {
    method getSmi (line 34797) | getSmi(pos) {
    method reset (line 34800) | reset() {
    method len (line 34803) | len() {
    method constructor (line 42087) | constructor() {
    method size (line 42091) | get size() {
    method push (line 42094) | push(item) {
    method pop (line 42098) | pop() {
    method isEmpty (line 42104) | isEmpty() {
  class ListNode (line 42109) | class ListNode {
    method constructor (line 42110) | constructor(value) {
  class LinkedList (line 42116) | class LinkedList {
    method constructor (line 42117) | constructor() {
    method head (line 42120) | head() {
    method tail (line 42123) | tail() {
    method clear (line 42126) | clear() {
    method toArray (line 42129) | toArray() {
    method nextNode (line 42134) | nextNode(node) {
    method forEachNode (line 42137) | forEachNode(callback) {
    method insertBefore (line 42144) | insertBefore(node, reference = null) {
    method append (line 42152) | append(node) {
    method remove (line 42163) | remove(node) {
  class ListSlice (line 42169) | class ListSlice {
    method constructor (line 42170) | constructor(head, tail) {
    method forEachNode (line 42174) | forEachNode(callback) {
    method head (line 42181) | head() {
    method tail (line 42184) | tail() {
    method toArray (line 42187) | toArray() {
    method nextNode (line 42192) | nextNode(node) {
  function is (line 42290) | function is(variant) {
  function isAttribute (line 42298) | function isAttribute(val) {
  function isArgument (line 42301) | function isArgument(val) {
  function buildPlatform (line 42322) | function buildPlatform(flush) {
  function isCoercableNumber (line 42358) | function isCoercableNumber(suspect) {
  function getOnError (line 42362) | function getOnError(options) {
  function findItem (line 42365) | function findItem(target, method, collection) {
  function findTimerItem (line 42375) | function findTimerItem(target, method, collection) {
  function getQueueItems (line 42385) | function getQueueItems(items, queueItemLength, queueItemPositionOffset =...
  function binarySearch (line 42400) | function binarySearch(time, timers) {
  class Queue (line 42422) | class Queue {
    method constructor (line 42423) | constructor(name, options = {}, globalOptions = {}) {
    method stackFor (line 42432) | stackFor(index) {
    method flush (line 42442) | flush(sync) {
    method hasWork (line 42501) | hasWork() {
    method cancel (line 42504) | cancel({ target, method }) {
    method push (line 42525) | push(target, method, args, stack) {
    method pushUnique (line 42533) | pushUnique(target, method, args, stack) {
    method _getDebugInfo (line 42554) | _getDebugInfo(debugEnabled) {
    method invoke (line 42561) | invoke(target, method, args /*, onError, errorRecordedForStack */) {
    method invokeWithOnError (line 42568) | invokeWithOnError(target, method, args, onError, errorRecordedForStack) {
  class DeferredActionQueues (line 42581) | class DeferredActionQueues {
    method constructor (line 42582) | constructor(queueNames = [], options) {
    method schedule (line 42601) | schedule(queueName, target, method, args, onceFlag, stack) {
    method flush (line 42623) | flush(fromAutorun = false) {
    method _getDebugInfo (line 42649) | _getDebugInfo(debugEnabled) {
  function iteratorDrain (line 42668) | function iteratorDrain(fn) {
  function parseArgs (line 42679) | function parseArgs() {
  function parseTimerArgs (line 42713) | function parseTimerArgs() {
  function parseDebounceArgs (line 42725) | function parseDebounceArgs() {
  class Backburner (line 42772) | class Backburner {
    method constructor (line 42773) | constructor(queueNames, options) {
    method counters (line 42808) | get counters() {
    method defaultQueue (line 42839) | get defaultQueue() {
    method begin (line 42846) | begin() {
    method end (line 42867) | end() {
    method on (line 42871) | on(eventName, callback) {
    method off (line 42882) | off(eventName, callback) {
    method run (line 42901) | run() {
    method join (line 42906) | join() {
    method defer (line 42914) | defer(queueName, target, method, ...args) {
    method schedule (line 42918) | schedule(queueName, ..._args) {
    method scheduleIterable (line 42931) | scheduleIterable(queueName, iterable) {
    method deferOnce (line 42939) | deferOnce(queueName, target, method, ...args) {
    method scheduleOnce (line 42943) | scheduleOnce(queueName, ..._args) {
    method setTimeout (line 42949) | setTimeout() {
    method later (line 42953) | later() {
    method throttle (line 42958) | throttle() {
    method debounce (line 42977) | debounce() {
    method cancelTimers (line 43010) | cancelTimers() {
    method hasTimers (line 43016) | hasTimers() {
    method cancel (line 43019) | cancel(timer) {
    method ensureInstance (line 43034) | ensureInstance() {
    method getDebugInfo (line 43044) | getDebugInfo() {
    method _end (line 43055) | _end(fromAutorun) {
    method _join (line 43084) | _join(target, method, args) {
    method _run (line 43094) | _run(target, method, args) {
    method _cancelAutorun (line 43113) | _cancelAutorun() {
    method _later (line 43120) | _later(target, method, args, wait) {
    method _cancelLaterTimer (line 43136) | _cancelLaterTimer(timer) {
    method _trigger (line 43159) | _trigger(eventName, arg1, arg2) {
    method _runExpiredTimers (line 43167) | _runExpiredTimers() {
    method _scheduleExpiredTimers (line 43175) | _scheduleExpiredTimers() {
    method _reinstallTimerTimeout (line 43197) | _reinstallTimerTimeout() {
    method _clearTimerTimeout (line 43201) | _clearTimerTimeout() {
    method _installTimerTimeout (line 43208) | _installTimerTimeout() {
    method _ensureInstance (line 43217) | _ensureInstance() {
    method _scheduleAutorun (line 43226) | _scheduleAutorun() {
  function DAG (line 43247) | function DAG() {
  function Vertices (line 43312) | function Vertices() {
  function IntStack (line 43431) | function IntStack() {
  function classCallCheck (line 43456) | function classCallCheck(instance, Constructor) {
  function inherits (line 43464) | function inherits(subClass, superClass) {
  function taggedTemplateLiteralLoose (line 43481) | function taggedTemplateLiteralLoose(strings, raw) {
  function defineProperties (line 43486) | function defineProperties(target, props) {
  function createClass (line 43496) | function createClass(Constructor, protoProps, staticProps) {
  method get (line 43538) | get() {
  function createMap (line 44038) | function createMap() {
  function generateMatch (line 44080) | function generateMatch(startingPath, matcher, delegate) {
  function addRoute (line 44092) | function addRoute(routeArray, path, handler) {
  function eachRoute (line 44101) | function eachRoute(baseRoute, matcher, callback, binding) {
  function normalizePath (line 44133) | function normalizePath(path) {
  function normalizeSegment (line 44140) | function normalizeSegment(segment) {
  function encodePathSegment (line 44157) | function encodePathSegment(str) {
  function getParam (line 44164) | function getParam(params, key) {
  function parse (line 44233) | function parse(segments, route, types) {
  function isEqualCharSpec (line 44276) | function isEqualCharSpec(spec, char, negate) {
  function isMatch (line 44379) | function isMatch(spec, char) {
  function sortSolutions (line 44392) | function sortSolutions(states) {
  function recognizeChar (line 44422) | function recognizeChar(states, ch) {
  function findHandler (line 44438) | function findHandler(state, originalPath, queryParams) {
  function decodeQueryParamPart (line 44477) | function decodeQueryParamPart(part) {
  function TransitionAbortedError (line 44719) | function TransitionAbortedError(message) {
  function isPromise (line 44737) | function isPromise(p) {
  function merge (line 44740) | function merge(hash, other) {
  function extractQueryParams (line 44752) | function extractQueryParams(array) {
  function isQueryParams (line 44766) | function isQueryParams(obj) {
  function coerceQueryParamsToString (line 44774) | function coerceQueryParamsToString(queryParams) {
  function log (line 44789) | function log(router, ...args) {
  function isParam (line 44801) | function isParam(object) {
  function forEach (line 44804) | function forEach(array, callback) {
  function getChangelist (line 44809) | function getChangelist(oldObject, newObject) {
  function isArray (line 44854) | function isArray(obj) {
  function promiseLabel (line 44857) | function promiseLabel(label) {
  class Transition (line 44879) | class Transition {
    method constructor (line 44880) | constructor(router, intent, state, error = undefined, previousTransiti...
    method then (line 44984) | then(onFulfilled, onRejected, label) {
    method catch (line 44998) | catch(onRejection, label) {
    method finally (line 45012) | finally(callback, label) {
    method abort (line 45022) | abort() {
    method rollback (line 45032) | rollback() {
    method redirect (line 45043) | redirect(newTransition) {
    method retry (line 45055) | retry() {
    method method (line 45089) | method(method) {
    method send (line 45094) | send(ignoreFailure, _name, err, transition, handler) {
    method trigger (line 45107) | trigger(ignoreFailure, name, ...args) {
    method followRedirects (line 45121) | followRedirects() {
    method toString (line 45130) | toString() {
    method log (line 45136) | log(message) {
  function logAbort (line 45145) | function logAbort(transition) {
  function isTransition (line 45149) | function isTransition(obj) {
  function prepareResult (line 45152) | function prepareResult(obj) {
  function toReadOnlyRouteInfo (line 45160) | function toReadOnlyRouteInfo(routeInfos, queryParams = {}, includeAttrib...
  function createRouteInfoWithAttributes (line 45226) | function createRouteInfoWithAttributes(routeInfo, context) {
  function buildRouteInfoMetadata (line 45237) | function buildRouteInfoMetadata(route) {
  function attachMetadata (line 45243) | function attachMetadata(route, routeInfo) {
  class InternalRouteInfo (line 45254) | class InternalRouteInfo {
    method constructor (line 45255) | constructor(router, name, paramNames, route) {
    method getModel (line 45267) | getModel(_transition) {
    method serialize (line 45270) | serialize(_context) {
    method resolve (line 45273) | resolve(shouldContinue, transition) {
    method becomeResolved (line 45276) | becomeResolved(transition, resolvedContext) {
    method shouldSupercede (line 45295) | shouldSupercede(routeInfo) {
    method route (line 45308) | get route() {
    method route (line 45316) | set route(route) {
    method routePromise (line 45319) | get routePromise() {
    method routePromise (line 45326) | set routePromise(routePromise) {
    method log (line 45329) | log(transition, message) {
    method updateRoute (line 45334) | updateRoute(route) {
    method runBeforeModelHook (line 45337) | runBeforeModelHook(transition) {
    method runAfterModelHook (line 45352) | runAfterModelHook(transition, resolvedModel) {
    method checkForAbort (line 45372) | checkForAbort(shouldContinue, value) {
    method stashResolvedModel (line 45379) | stashResolvedModel(transition, resolvedModel) {
    method fetchRoute (line 45383) | fetchRoute() {
    method _processRoute (line 45387) | _processRoute(route) {
  class ResolvedRouteInfo (line 45404) | class ResolvedRouteInfo extends InternalRouteInfo {
    method constructor (line 45405) | constructor(router, name, paramNames, params, route, context) {
    method resolve (line 45411) | resolve(_shouldContinue, transition) {
  class UnresolvedRouteInfoByParam (line 45419) | class UnresolvedRouteInfoByParam extends InternalRouteInfo {
    method constructor (line 45420) | constructor(router, name, paramNames, params, route) {
    method getModel (line 45425) | getModel(transition) {
  class UnresolvedRouteInfoByObject (line 45445) | class UnresolvedRouteInfoByObject extends InternalRouteInfo {
    method constructor (line 45446) | constructor(router, name, paramNames, context) {
    method getModel (line 45451) | getModel(transition) {
    method serialize (line 45464) | serialize(model) {
  function paramsMatch (line 45495) | function paramsMatch(a, b) {
  class TransitionIntent (line 45515) | class TransitionIntent {
    method constructor (line 45516) | constructor(router, data = {}) {
  class TransitionState (line 45522) | class TransitionState {
    method constructor (line 45523) | constructor() {
    method promiseLabel (line 45528) | promiseLabel(label) {
    method resolve (line 45539) | resolve(shouldContinue, transition) {
  class TransitionError (line 45600) | class TransitionError {
    method constructor (line 45601) | constructor(error, route, wasAborted, state) {
  class NamedTransitionIntent (line 45609) | class NamedTransitionIntent extends TransitionIntent {
    method constructor (line 45610) | constructor(router, name, pivotHandler, contexts = [], queryParams = {...
    method applyToState (line 45618) | applyToState(oldState, isIntermediate) {
    method applyToHandlers (line 45626) | applyToHandlers(oldState, parsedHandlers, targetRouteName, isIntermedi...
    method invalidateChildren (line 45691) | invalidateChildren(handlerInfos, invalidateIndex) {
    method getHandlerInfoForDynamicSegment (line 45700) | getHandlerInfoForDynamicSegment(name, names, objects, oldHandlerInfo, ...
    method createParamHandlerInfo (line 45730) | createParamHandlerInfo(name, names, objects, oldHandlerInfo) {
  function UnrecognizedURLError (line 45759) | function UnrecognizedURLError(message) {
  class URLTransitionIntent (line 45772) | class URLTransitionIntent extends TransitionIntent {
    method constructor (line 45773) | constructor(router, url, data) {
    method applyToState (line 45778) | applyToState(oldState) {
  class Router (line 45826) | class Router {
    method constructor (line 45827) | constructor(logger) {
    method map (line 45846) | map(callback) {
    method hasRoute (line 45856) | hasRoute(route) {
    method queryParamsTransition (line 45859) | queryParamsTransition(changelist, wasTransitioning, oldState, newState) {
    method transitionByIntent (line 45888) | transitionByIntent(intent, isIntermediate) {
    method recognize (line 45895) | recognize(url) {
    method recognizeAndLoad (line 45904) | recognizeAndLoad(url) {
    method generateNewState (line 45916) | generateNewState(intent) {
    method getTransitionByIntent (line 45923) | getTransitionByIntent(intent, isIntermediate) {
    method doTransition (line 45980) | doTransition(name, modelsArray = [], isIntermediate = false) {
    method finalizeTransition (line 46007) | finalizeTransition(transition, newState) {
    method setupContexts (line 46073) | setupContexts(newState, transition) {
    method fireQueryParamDidChange (line 46117) | fireQueryParamDidChange(newState, queryParamChangelist) {
    method routeEnteredOrUpdated (line 46133) | routeEnteredOrUpdated(currentRouteInf

[
  {
    "path": ".github/dependabot.yml",
    "chars": 561,
    "preview": "version: 2\nupdates:\n- package-ecosystem: npm\n  directory: \"/\"\n  schedule:\n    interval: monthly\n  open-pull-requests-lim"
  },
  {
    "path": ".github/workflows/test-and-lint.yml",
    "chars": 368,
    "preview": "name: CI\n\non:\n  push:\n    branches: [master]\n  pull_request:\n    branches: [master]\n\njobs:\n  test-and-lint:\n    name: Ru"
  },
  {
    "path": ".gitignore",
    "chars": 262,
    "preview": ".Rapp.history\ndist/\nnode_modules/\nvendor/\n/packages/core/test/results/\ntmp/\n/*workspace\n*.log\n*.tgz\n*.tmp\n.nyc_output\n/p"
  },
  {
    "path": ".husky/.gitignore",
    "chars": 2,
    "preview": "_\n"
  },
  {
    "path": ".husky/pre-push",
    "chars": 68,
    "preview": "#!/bin/sh\n. \"$(dirname \"$0\")/_/husky.sh\"\n\nyarn lint && yarn prepack\n"
  },
  {
    "path": ".prettierrc",
    "chars": 52,
    "preview": "{\n  \"trailingComma\": \"none\",\n  \"singleQuote\": true\n}"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 17244,
    "preview": "##  8.0.1 (2022-09-07)\n\n* fix: downgrade node to 14.x to satisfy app depends on tracerbench ([a1c4ea7](https://github.co"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 5132,
    "preview": "LinkedIn Open Source Code of Conduct\n-------------------------------------\n\nThis code of conduct outlines expectations f"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 630,
    "preview": "# Contributing Guide\n\n## Community\n\nWe welcome issues and pull requests on GitHub!\n\nFor significant changes or enhanceme"
  },
  {
    "path": "LICENSE.md",
    "chars": 1328,
    "preview": "BSD 2-CLAUSE LICENSE\n\nCopyright 2019 LinkedIn Corporation and Contributors. All Rights Reserved.\n\nRedistribution and use"
  },
  {
    "path": "NOISE_MITIGATION.md",
    "chars": 2914,
    "preview": "# TracerBench: Noise Mitigation Techniques\n\nAs a general rule of thumb to \"zero-out\" your environment its recommended yo"
  },
  {
    "path": "NOTICE.md",
    "chars": 344,
    "preview": "Copyright 2018 LinkedIn Corporation and Contributors.\nAll Rights Reserved.\n\nLicensed under the BSD 2-Clause License (the"
  },
  {
    "path": "README.md",
    "chars": 982,
    "preview": "# TracerBench: Automated Chrome Tracing For Benchmarking\n\n[![Build Status](https://github.com/TracerBench/tracerbench/wo"
  },
  {
    "path": "commitlint.config.js",
    "chars": 481,
    "preview": "module.exports = {\n    extends: [\n        '@commitlint/config-conventional'\n    ],\n    rules: {\n        'type-enum': [\n "
  },
  {
    "path": "docs/travis-example.js",
    "chars": 2147,
    "preview": "#!/usr/bin/env node\n/* global require process */\n/* eslint-disable no-console */\n\nconst path = require('path');\nconst or"
  },
  {
    "path": "docs/travis-example.yml",
    "chars": 263,
    "preview": "language: node_js\nnode_js:\n  - '10'\nservices:\n  - mongodb\nsudo: false\ndist: trusty\n\naddons:\n  chrome: stable\n\ncache:\n  d"
  },
  {
    "path": "lerna.json",
    "chars": 169,
    "preview": "{\n  \"version\": \"8.0.1\",\n  \"packages\": [\n    \"packages/*\"\n  ],\n  \"ignoreChanges\": [\n    \"**/test/**\",\n    \"**/*.md\"\n  ],\n"
  },
  {
    "path": "package.json",
    "chars": 797,
    "preview": "{\n  \"name\": \"tracerbench-workspace\",\n  \"private\": true,\n  \"workspaces\": [\n    \"packages/*\"\n  ],\n  \"scripts\": {\n    \"lint"
  },
  {
    "path": "packages/cli/.eslintrc.js",
    "chars": 2107,
    "preview": "/* eslint-disable no-undef */\n/* eslint-disable filenames/match-regex */\n\nmodule.exports = {\n  root: true,\n  parser: \"@t"
  },
  {
    "path": "packages/cli/.gitignore",
    "chars": 133,
    "preview": "*trace-processed.json\ncookies.json\n*tracerbench-results*\ntrace.json\n*tsconfig.tsbuildinfo\n*tb-tmp*\nevents_output.json\n*s"
  },
  {
    "path": "packages/cli/.mocharc.json",
    "chars": 214,
    "preview": "{\n  \"require\": \"ts-node/register\",\n  \"extension\": [\"ts\"],\n  \"watch-files\": [\"test/**/*.test.ts\"],\n  \"recursive\": true,\n "
  },
  {
    "path": "packages/cli/.prettierrc",
    "chars": 2,
    "preview": "{}"
  },
  {
    "path": "packages/cli/LICENSE.md",
    "chars": 1328,
    "preview": "BSD 2-CLAUSE LICENSE\n\nCopyright 2019 LinkedIn Corporation and Contributors. All Rights Reserved.\n\nRedistribution and use"
  },
  {
    "path": "packages/cli/README.md",
    "chars": 1198,
    "preview": "## TracerBench: Automated Chrome Tracing For Benchmarking\n\n[![Build Status](https://travis-ci.org/TracerBench/tracerbenc"
  },
  {
    "path": "packages/cli/bin/run",
    "chars": 160,
    "preview": "#!/usr/bin/env node\n\nrequire(\"@oclif/command\")\n  .run(undefined, __dirname)\n  .then(require(\"@oclif/command/flush\"))\n  ."
  },
  {
    "path": "packages/cli/bin/run.cmd",
    "chars": 31,
    "preview": "@echo off\n\nnode \"%~dp0\\run\" %*\n"
  },
  {
    "path": "packages/cli/markdown/commands.md",
    "chars": 459,
    "preview": "# `tracerbench`\n\nCLI for TracerBench\n\n- [`tracerbench [COMMAND]`](#tracerbench)\n\n## `tracerbench [COMMAND]`\n\n```\nVERSION"
  },
  {
    "path": "packages/cli/markdown/compare.md",
    "chars": 6110,
    "preview": "`tracerbench compare`\n=====================\n\nCompare the performance delta between an experiment and control\n\n* [`tracer"
  },
  {
    "path": "packages/cli/markdown/help.md",
    "chars": 471,
    "preview": "`tracerbench help`\n==================\n\nDisplay help for tracerbench.\n\n* [`tracerbench help [COMMAND]`](#tracerbench-help"
  },
  {
    "path": "packages/cli/markdown/profile.md",
    "chars": 1152,
    "preview": "`tracerbench profile`\n=====================\n\nParses a CPU profile with asset and marker timings\n\n* [`tracerbench profile"
  },
  {
    "path": "packages/cli/markdown/record-har.md",
    "chars": 3198,
    "preview": "`tracerbench record-har`\n========================\n\nGenerates a HAR file from a URL\n\n* [`tracerbench record-har`](#tracer"
  },
  {
    "path": "packages/cli/oclif.manifest.json",
    "chars": 9903,
    "preview": "{\"version\":\"8.0.1\",\"commands\":{\"compare:analyze\":{\"id\":\"compare:analyze\",\"description\":\"Generates stdout report from the"
  },
  {
    "path": "packages/cli/package.json",
    "chars": 3790,
    "preview": "{\n  \"name\": \"tracerbench\",\n  \"version\": \"8.0.1\",\n  \"description\": \"CLI for TracerBench\",\n  \"keywords\": [\n    \"oclif\"\n  ]"
  },
  {
    "path": "packages/cli/src/command-config/build-config.ts",
    "chars": 4492,
    "preview": "import { OutputFlags } from \"@oclif/parser\";\nimport * as fs from \"fs-extra\";\nimport * as JSON5 from \"json5\";\nimport * as"
  },
  {
    "path": "packages/cli/src/command-config/default-flag-args.ts",
    "chars": 1564,
    "preview": "import { ITBConfig } from \"./tb-config\";\n\nexport const fidelityLookup = {\n  test: 2,\n  low: 20,\n  medium: 30,\n  high: 50"
  },
  {
    "path": "packages/cli/src/command-config/index.ts",
    "chars": 427,
    "preview": "import TBBaseCommand, { flags } from \"./tb-base\";\n\nexport {\n  ITBConfig,\n  IHARServer,\n  RegressionThresholdStat,\n  IBen"
  },
  {
    "path": "packages/cli/src/command-config/tb-base.ts",
    "chars": 595,
    "preview": "/* eslint-disable filenames/match-exported */\nimport { Command } from \"@oclif/command\";\nimport { IConfig } from \"@oclif/"
  },
  {
    "path": "packages/cli/src/command-config/tb-config.ts",
    "chars": 1985,
    "preview": "/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { INetworkConditions, Marker } from \"@tracerbench/core\";\n"
  },
  {
    "path": "packages/cli/src/commands/compare/analyze.ts",
    "chars": 3958,
    "preview": "/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable filenames/match-exported */\nimport { IConfig }"
  },
  {
    "path": "packages/cli/src/commands/compare/index.ts",
    "chars": 15335,
    "preview": "/* eslint-disable @typescript-eslint/no-non-null-assertion */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\ni"
  },
  {
    "path": "packages/cli/src/commands/compare/report.ts",
    "chars": 7634,
    "preview": "/* eslint-disable filenames/match-exported */\n\nimport { IConfig } from \"@oclif/config\";\nimport { existsSync, mkdirSync, "
  },
  {
    "path": "packages/cli/src/commands/record-har/auth.ts",
    "chars": 3467,
    "preview": "/* eslint-disable filenames/match-exported */\nimport { authClient } from \"@tracerbench/core\";\nimport Protocol from \"devt"
  },
  {
    "path": "packages/cli/src/commands/record-har/index.ts",
    "chars": 5068,
    "preview": "import { flags as oclifFlags } from \"@oclif/command\";\nimport { IConditions, recordHARClient } from \"@tracerbench/core\";\n"
  },
  {
    "path": "packages/cli/src/compare/compare-results.ts",
    "chars": 9406,
    "preview": "/* eslint-disable no-case-declarations */\nimport type {\n  IAsPercentage,\n  IConfidenceInterval,\n  ISevenFigureSummary,\n}"
  },
  {
    "path": "packages/cli/src/compare/generate-stats.ts",
    "chars": 8107,
    "preview": "import type { IConfidenceInterval } from \"@tracerbench/stats\";\nimport {\n  convertMicrosecondsToMS,\n  roundFloatAndConver"
  },
  {
    "path": "packages/cli/src/compare/index.ts",
    "chars": 249,
    "preview": "import printToPDF from \"./print-to-pdf\";\n\nexport {\n  ITracerBenchTraceResult,\n  GenerateStats,\n  HTMLSectionRenderData,\n"
  },
  {
    "path": "packages/cli/src/compare/parse-compare-result.ts",
    "chars": 1403,
    "preview": "import { readFileSync } from \"fs-extra\";\nimport * as JSON5 from \"json5\";\nimport { resolve } from \"path\";\n\nimport type { "
  },
  {
    "path": "packages/cli/src/compare/print-to-pdf.ts",
    "chars": 1600,
    "preview": "import { spawnChrome } from \"chrome-debugging-client\";\nimport { writeFileSync } from \"fs-extra\";\nimport * as listr from "
  },
  {
    "path": "packages/cli/src/compare/tb-table.ts",
    "chars": 6118,
    "preview": "/* eslint-disable prefer-const */\nimport type { Stats } from \"@tracerbench/stats\";\nimport * as chalk from \"chalk\";\nimpor"
  },
  {
    "path": "packages/cli/src/helpers/args.ts",
    "chars": 266,
    "preview": "export const harpath = {\n  name: \"harpath\",\n  required: true,\n  description: \"The path to the HTTP Archive File (HAR)\",\n"
  },
  {
    "path": "packages/cli/src/helpers/device-lookup.ts",
    "chars": 37437,
    "preview": "export interface IDeviceLookup {\n  type: string;\n  order?: number;\n  device: {\n    \"show-by-default\": boolean;\n    \"user"
  },
  {
    "path": "packages/cli/src/helpers/device-settings.ts",
    "chars": 2537,
    "preview": "import { CLIError } from \"@oclif/errors\";\nimport Protocol from \"devtools-protocol\";\n\nimport { deviceLookup, IDeviceLooku"
  },
  {
    "path": "packages/cli/src/helpers/flags.ts",
    "chars": 9104,
    "preview": "/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint:disable:no-console*/\nimport { flags as oclifFlags } fr"
  },
  {
    "path": "packages/cli/src/helpers/index.ts",
    "chars": 357,
    "preview": "import deviceSettings, {\n  EmulateDeviceSetting,\n  getEmulateDeviceSettingForKeyAndOrientation,\n} from \"./device-setting"
  },
  {
    "path": "packages/cli/src/helpers/utils.ts",
    "chars": 6014,
    "preview": "/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/no-explicit-a"
  },
  {
    "path": "packages/cli/src/index.ts",
    "chars": 771,
    "preview": "import Compare from \"./commands/compare\";\nimport CompareAnalyze from \"./commands/compare/analyze\";\nimport CompareReport,"
  },
  {
    "path": "packages/cli/src/static/chart-bootstrap.css",
    "chars": 189115,
    "preview": "*/:root {\n  --blue: #007bff;\n  --indigo: #6610f2;\n  --purple: #6f42c1;\n  --pink: #e83e8c;\n  --red: #dc3545;\n  --orange: "
  },
  {
    "path": "packages/cli/src/static/index.ts",
    "chars": 1234,
    "preview": "import { readFileSync } from \"fs-extra\";\nimport { join } from \"path\";\n\nconst CHART_CSS_PATH = join(__dirname, \"chart-boo"
  },
  {
    "path": "packages/cli/src/static/phase-chart-js-partial.hbs",
    "chars": 3936,
    "preview": "<script>\n  const canvasFor{{#toCamel analysisForPhase.identifierHash}}{{/toCamel}} = document.getElementById('{{analysis"
  },
  {
    "path": "packages/cli/src/static/phase-detail-partial.hbs",
    "chars": 2912,
    "preview": "<div class=\"avoid-page-break\">\n  <div class=\"row\">\n    <div class=\"col\">\n      <h2 class=\"phase\">{{analysisForPhase.phas"
  },
  {
    "path": "packages/cli/src/static/report-template.hbs",
    "chars": 3991,
    "preview": "<html>\n\n<head>\n  <meta charset=\"utf-8\">\n  <title>{{reportTitles.plotTitle}}</title>\n  <meta name=\"description\" content=\""
  },
  {
    "path": "packages/cli/src/static/tb-bootstrap.css",
    "chars": 18511,
    "preview": "header {\n  margin: 0 auto 1.2rem;\n  align-items: center;\n  display: flex;\n  border-bottom: 1px solid rgba(0,0,0,0.1);\n}\n"
  },
  {
    "path": "packages/cli/tb-schema.json",
    "chars": 7393,
    "preview": "{\n    \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n    \"additionalProperties\": {},\n    \"definitions\": {\n       "
  },
  {
    "path": "packages/cli/test/command-config/build-config.test.ts",
    "chars": 3799,
    "preview": "import { ICompareFlags } from \"../../src/commands/compare\";\nimport { checkEnvironmentSpecificOverride } from \"../../src/"
  },
  {
    "path": "packages/cli/test/commands/analyze.test.ts",
    "chars": 2283,
    "preview": "import { test } from \"@oclif/test\";\nimport { expect, assert } from \"chai\";\nimport { dirname, join } from \"path\";\nimport "
  },
  {
    "path": "packages/cli/test/commands/auth.test.ts",
    "chars": 432,
    "preview": "import { test } from \"@oclif/test\";\nimport { expect } from \"chai\";\nimport { describe } from \"mocha\";\n\nimport RecordHARAu"
  },
  {
    "path": "packages/cli/test/commands/compare.test.ts",
    "chars": 7957,
    "preview": "import { test } from \"@oclif/test\";\nimport { expect, assert } from \"chai\";\nimport { describe } from \"mocha\";\n\nimport Com"
  },
  {
    "path": "packages/cli/test/commands/record-har.test.ts",
    "chars": 3344,
    "preview": "import { test } from \"@oclif/test\";\nimport { Archive } from \"@tracerbench/har\";\nimport { LCP_EVENT_NAME_ALIAS } from \"@t"
  },
  {
    "path": "packages/cli/test/commands/report.test.ts",
    "chars": 4446,
    "preview": "import { test } from \"@oclif/test\";\nimport { expect, assert } from \"chai\";\nimport { describe } from \"mocha\";\n\nimport { r"
  },
  {
    "path": "packages/cli/test/compare/compare-results.test.ts",
    "chars": 6060,
    "preview": "import { expect } from \"chai\";\nimport { describe } from \"mocha\";\n\nimport { readJsonSync } from \"fs-extra\";\nimport {\n  Ge"
  },
  {
    "path": "packages/cli/test/compare/generate-stats.test.ts",
    "chars": 9388,
    "preview": "import { expect } from \"chai\";\nimport { describe } from \"mocha\";\n\nimport { readJsonSync } from \"fs-extra\";\nimport {\n  Ge"
  },
  {
    "path": "packages/cli/test/compare/parse-compare-result.test.ts",
    "chars": 829,
    "preview": "import { expect } from \"chai\";\nimport { describe } from \"mocha\";\n\nimport { test } from \"@oclif/test\";\n\nimport parseCompa"
  },
  {
    "path": "packages/cli/test/compare/print-to-pdf.test.ts",
    "chars": 517,
    "preview": "import { assert } from \"chai\";\nimport { describe } from \"mocha\";\n\nimport { join } from \"path\";\nimport { pathToFileURL } "
  },
  {
    "path": "packages/cli/test/compare/tb-table.test.ts",
    "chars": 4238,
    "preview": "import { expect } from \"chai\";\nimport { describe } from \"mocha\";\n\nimport {\n  Stats,\n  roundFloatAndConvertMicrosecondsTo"
  },
  {
    "path": "packages/cli/test/fixtures/experiment/app.js",
    "chars": 1777,
    "preview": "Ember.TEMPLATES[\"application\"] = Ember.HTMLBars.template({\n  id: null,\n  block:\n    '{\"symbols\":[],\"statements\":[[7,\"h1\""
  },
  {
    "path": "packages/cli/test/fixtures/experiment/ember.prod.js",
    "chars": 1792298,
    "preview": "(function() {\n/*!\n * @overview  Ember - JavaScript Application Framework\n * @copyright Copyright 2011-2018 Tilde Inc. an"
  },
  {
    "path": "packages/cli/test/fixtures/experiment/index.html",
    "chars": 345,
    "preview": "<html>\n\n<head>\n  <title>Test Initial Render</title>\n\n  <script src=\"./jquery.min.js\"></script>\n  <script>\n    if ($) per"
  },
  {
    "path": "packages/cli/test/fixtures/experiment/tbconfig.json",
    "chars": 81,
    "preview": "{\n  \"extends\": \"../../tbconfig_base.json\",\n  \"plotTitle\": \"fixtures experiment\"\n}"
  },
  {
    "path": "packages/cli/test/fixtures/regression/app.js",
    "chars": 1812,
    "preview": "Ember.TEMPLATES[\"application\"] = Ember.HTMLBars.template({\n  id: null,\n  block:\n    '{\"symbols\":[],\"statements\":[[7,\"h1\""
  },
  {
    "path": "packages/cli/test/fixtures/regression/ember.prod.js",
    "chars": 2071570,
    "preview": "(function () {\n    /*!\n     * @overview  Ember - JavaScript Application Framework\n     * @copyright Copyright 2011-2018 "
  },
  {
    "path": "packages/cli/test/fixtures/regression/index.html",
    "chars": 399,
    "preview": "<html>\n\n<head>\n  <title>Test Initial Render</title>\n  <script src=\"./jquery.min.js\"></script>\n  <script>\n    if ($) perf"
  },
  {
    "path": "packages/cli/test/fixtures/regression/tbconfig.json",
    "chars": 81,
    "preview": "{\n  \"extends\": \"../../tbconfig_base.json\",\n  \"plotTitle\": \"fixtures regression\"\n}"
  },
  {
    "path": "packages/cli/test/fixtures/release/app.js",
    "chars": 1777,
    "preview": "Ember.TEMPLATES[\"application\"] = Ember.HTMLBars.template({\n  id: null,\n  block:\n    '{\"symbols\":[],\"statements\":[[7,\"h1\""
  },
  {
    "path": "packages/cli/test/fixtures/release/ember.prod.js",
    "chars": 2071570,
    "preview": "(function () {\n    /*!\n     * @overview  Ember - JavaScript Application Framework\n     * @copyright Copyright 2011-2018 "
  },
  {
    "path": "packages/cli/test/fixtures/release/index.html",
    "chars": 345,
    "preview": "<html>\n\n<head>\n  <title>Test Initial Render</title>\n\n  <script src=\"./jquery.min.js\"></script>\n  <script>\n    if ($) per"
  },
  {
    "path": "packages/cli/test/fixtures/release/tbconfig.json",
    "chars": 448,
    "preview": "{\n  \"$schema\": \"https://raw.githubusercontent.com/TracerBench/tracerbench/master/packages/cli/tb-schema.json\",\n  \"extend"
  },
  {
    "path": "packages/cli/test/fixtures/results/compare.json",
    "chars": 57263,
    "preview": "[{\n    \"meta\": {\n      \"browserVersion\": \"HeadlessChrome/81.0.4044.122\",\n      \"cpus\": [\n        \"Intel(R) Core(TM) i7-7"
  },
  {
    "path": "packages/cli/test/fixtures/results/fixture.har",
    "chars": 995901,
    "preview": "{\n  \"log\": {\n    \"version\": \"0.0.0\",\n    \"creator\": { \"name\": \"TracerBench\", \"version\": \"3.1.1\" },\n    \"entries\": [\n    "
  },
  {
    "path": "packages/cli/test/fixtures/results/mock-cookies.json",
    "chars": 446,
    "preview": "{\n  \"storeType\": \"MemoryCookieStore\",\n  \"rejectPublicSuffixes\": true,\n  \"cookies\": [{\n      \"key\": \"tracerbench-fake\",\n "
  },
  {
    "path": "packages/cli/test/fixtures/results/mock-trace.json",
    "chars": 5489,
    "preview": "{\n  \"traceEvents\": [{\n      \"pid\": 68210,\n      \"tid\": 37635,\n      \"ts\": 50482038680,\n      \"ph\": \"M\",\n      \"cat\": \"__"
  },
  {
    "path": "packages/cli/test/fixtures/results/report.json",
    "chars": 3886,
    "preview": "{\"benchmarkTableData\":[{\"heading\":\"Initial Render\",\"phaseName\":\"duration\",\"isSignificant\":true,\"pValue\":6.796e-8,\"estima"
  },
  {
    "path": "packages/cli/test/fixtures/results/stats.ts",
    "chars": 7495,
    "preview": "// real world test running tracerbench with\n// heavy app usage and ambient work 50 samples\nexport const HIGH_VARIANCE_RE"
  },
  {
    "path": "packages/cli/test/helpers/simulate-device-options.test.ts",
    "chars": 880,
    "preview": "import { getEmulateDeviceSettingForKeyAndOrientation } from \"../../src/helpers/device-settings\";\nimport { expect } from "
  },
  {
    "path": "packages/cli/test/helpers/utils.test.ts",
    "chars": 1748,
    "preview": "import {\n  convertMSToMicroseconds,\n  mergeLeft,\n  parseMarkers,\n  secondsToTime\n} from \"../../src/helpers/utils\";\nimpor"
  },
  {
    "path": "packages/cli/test/setup.ts",
    "chars": 85,
    "preview": "import { setGracefulCleanup } from 'tmp';\n\nafter(() => {\n  setGracefulCleanup();\n});\n"
  },
  {
    "path": "packages/cli/test/tbconfig.json",
    "chars": 148,
    "preview": "{\n  \"$schema\": \"https://raw.githubusercontent.com/TracerBench/tracerbench/master/packages/cli/tb-schema.json\",\n  \"extend"
  },
  {
    "path": "packages/cli/test/tbconfig_base.json",
    "chars": 2057,
    "preview": "{\n  \"$schema\": \"https://raw.githubusercontent.com/TracerBench/tracerbench/master/packages/cli/tb-schema.json\",\n  // the "
  },
  {
    "path": "packages/cli/test/test-helpers.ts",
    "chars": 2178,
    "preview": "import { dirSync } from \"tmp\";\nimport { pathToFileURL } from \"url\";\nimport { join, resolve } from \"path\";\nimport { mkdir"
  },
  {
    "path": "packages/cli/test/tsconfig.json",
    "chars": 131,
    "preview": "{\n  \"extends\": \"../tsconfig\",\n  \"compilerOptions\": {\n    \"outDir\": \"../dist/test/\"\n  },\n  \"references\": [\n    {\"path\": \""
  },
  {
    "path": "packages/cli/tsconfig.json",
    "chars": 663,
    "preview": "{\n  \"$schema\": \"http://json.schemastore.org/tsconfig\",\n  \"compilerOptions\": {\n    \"composite\": true,\n    \"declaration\": "
  },
  {
    "path": "packages/core/.eslintrc.js",
    "chars": 2002,
    "preview": "module.exports = {\n  root: true,\n  parser: '@typescript-eslint/parser',\n  parserOptions: {\n    sourceType: 'module'\n  },"
  },
  {
    "path": "packages/core/.prettierrc",
    "chars": 52,
    "preview": "{\n  \"trailingComma\": \"none\",\n  \"singleQuote\": true\n}"
  },
  {
    "path": "packages/core/LICENSE.md",
    "chars": 1328,
    "preview": "BSD 2-CLAUSE LICENSE\n\nCopyright 2019 LinkedIn Corporation and Contributors. All Rights Reserved.\n\nRedistribution and use"
  },
  {
    "path": "packages/core/README.md",
    "chars": 281,
    "preview": "## TracerBench: Automated Chrome Tracing For Benchmarking\n\n[![Build Status](https://travis-ci.org/TracerBench/tracerbenc"
  },
  {
    "path": "packages/core/bin/ResultSets.R",
    "chars": 6216,
    "preview": "library(R6)\nsuppressMessages(library(jsonlite))\n\nCursor <- R6Class(\"Cursor\",\n  portable = F,\n  cloneable = F,\n  public ="
  },
  {
    "path": "packages/core/bin/plot.R",
    "chars": 2466,
    "preview": "#!/usr/bin/env Rscript\n\nargv <- commandArgs()\n\nm <- grep(\"--file\", argv)\nsrcDir <- if (m) dirname(substring(argv[m], 8))"
  },
  {
    "path": "packages/core/bin/report.R",
    "chars": 1809,
    "preview": "#!/usr/bin/env Rscript\n\nargv <- commandArgs()\n\nm <- grep(\"--file\", argv)\nsrcDir <- if (m) dirname(substring(argv[m], 8))"
  },
  {
    "path": "packages/core/bin/runtime-stats.R",
    "chars": 2100,
    "preview": "#!/usr/bin/env Rscript\n\nargv <- commandArgs()\n\nm <- grep(\"--file\", argv)\nsrcDir <- if (m) dirname(substring(argv[m], 8))"
  },
  {
    "path": "packages/core/package.json",
    "chars": 2560,
    "preview": "{\n  \"name\": \"@tracerbench/core\",\n  \"version\": \"8.0.1\",\n  \"description\": \"Benchmark runner for trace metrics\",\n  \"keyword"
  },
  {
    "path": "packages/core/src/create-isolated-page-benchmark.ts",
    "chars": 3078,
    "preview": "import {\n  RootConnection,\n  SessionConnection,\n  spawnChrome,\n  SpawnOptions\n} from 'chrome-debugging-client';\n\nimport "
  },
  {
    "path": "packages/core/src/create-trace-benchmark.ts",
    "chars": 4432,
    "preview": "import { TraceStreamJson } from '@tracerbench/trace-event';\nimport type { ProtocolConnection, SpawnOptions } from 'chrom"
  },
  {
    "path": "packages/core/src/create-trace-navigation-benchmark.ts",
    "chars": 2358,
    "preview": "import { buildModel } from '@tracerbench/trace-model';\n\nimport type { TraceBenchmarkOptions } from './create-trace-bench"
  },
  {
    "path": "packages/core/src/index.ts",
    "chars": 1565,
    "preview": "export { default as createIsolatedPageBenchmark } from './create-isolated-page-benchmark';\nexport type { SamplePageFn } "
  },
  {
    "path": "packages/core/src/metrics/extract-navigation-sample.ts",
    "chars": 6010,
    "preview": "import { TraceEventArgs, TraceMetadata } from '@tracerbench/trace-event';\nimport {\n  CompleteEventModel,\n  EventModel,\n "
  },
  {
    "path": "packages/core/src/run.ts",
    "chars": 5510,
    "preview": "import { throwIfCancelled, withRaceTimeout } from 'race-cancellation';\n\nimport gc from './util/gc';\n\nimport type { RaceC"
  },
  {
    "path": "packages/core/src/trace/archive-trace.ts",
    "chars": 9805,
    "preview": "import { Archive, Entry, Header } from '@tracerbench/har';\nimport { SessionConnection } from 'chrome-debugging-client';\n"
  },
  {
    "path": "packages/core/src/trace/auth.ts",
    "chars": 5443,
    "preview": "import type { Protocol } from 'devtools-protocol';\n\nimport { createBrowser, getBrowserArgs, getTab, wait } from './utils"
  },
  {
    "path": "packages/core/src/trace/conditions.ts",
    "chars": 2918,
    "preview": "import Protocol from 'devtools-protocol';\n\nexport interface IConditions {\n  network: keyof INetworkConditions & string;\n"
  },
  {
    "path": "packages/core/src/trace/index.ts",
    "chars": 328,
    "preview": "export * from './archive-trace';\nexport * from './auth';\nexport {\n  networkConditions,\n  IConditions,\n  INetworkConditio"
  },
  {
    "path": "packages/core/src/trace/utils.ts",
    "chars": 7956,
    "preview": "import type {\n  ChromeWithPipeConnection,\n  ProtocolConnection,\n  SessionConnection\n} from 'chrome-debugging-client';\nim"
  },
  {
    "path": "packages/core/src/tsconfig.json",
    "chars": 189,
    "preview": "{\n  \"extends\": \"../tsconfig_base.json\",\n  \"compilerOptions\": {\n    \"outDir\": \"../dist\"\n  },\n  \"references\": [{\n    \"path"
  },
  {
    "path": "packages/core/src/util/gc.ts",
    "chars": 603,
    "preview": "import { setFlagsFromString } from 'v8';\nimport { runInNewContext } from 'vm';\nimport debug = require('debug');\nconst de"
  },
  {
    "path": "packages/core/src/util/inject-mark-observer.ts",
    "chars": 4905,
    "preview": "import { ProtocolConnection } from 'chrome-debugging-client';\nimport Protocol from 'devtools-protocol';\nimport { enforce"
  },
  {
    "path": "packages/core/src/util/interfaces.ts",
    "chars": 64,
    "preview": "export interface Screenshot {\n  name: string;\n  data: string;\n}\n"
  },
  {
    "path": "packages/core/src/util/is-navigation-timing-mark.ts",
    "chars": 671,
    "preview": "const navigationMarks = {\n  workerStart: true,\n  redirectStart: true,\n  redirectEnd: true,\n  fetchStart: true,\n  domainL"
  },
  {
    "path": "packages/core/src/util/navigate.ts",
    "chars": 670,
    "preview": "import { ProtocolConnection } from 'chrome-debugging-client';\nimport Protocol from 'devtools-protocol';\nimport type { Ra"
  },
  {
    "path": "packages/core/src/util/read-handle.ts",
    "chars": 1078,
    "preview": "import { ProtocolConnection } from 'chrome-debugging-client';\nimport Protocol from 'devtools-protocol';\nimport type { Ra"
  },
  {
    "path": "packages/core/src/util/run-trace.ts",
    "chars": 2524,
    "preview": "import type { TraceStreamJson } from '@tracerbench/trace-event';\nimport type { ProtocolConnection } from 'chrome-debuggi"
  },
  {
    "path": "packages/core/src/util/setup-page.ts",
    "chars": 1934,
    "preview": "import type { ProtocolConnection } from 'chrome-debugging-client';\nimport type { Protocol } from 'devtools-protocol';\nim"
  },
  {
    "path": "packages/core/test/build/build.ts",
    "chars": 1177,
    "preview": "import { mkdirSync, readFileSync, writeFileSync } from 'fs';\nimport { join } from 'path';\nimport compileTemplates from '"
  },
  {
    "path": "packages/core/test/build/compile_templates.ts",
    "chars": 678,
    "preview": "import { readFileSync } from 'fs';\nimport { sync as globSync } from 'glob';\n\nexport default function compileTemplates(\n "
  },
  {
    "path": "packages/core/test/build/copy_jquery.ts",
    "chars": 529,
    "preview": "import { readFileSync, writeFileSync } from \"fs\";\nimport { join } from \"path\";\n\nexport default function copyJquery(root:"
  },
  {
    "path": "packages/core/test/build/download_embers.ts",
    "chars": 2260,
    "preview": "import { readFileSync } from 'fs';\nimport { IncomingMessage } from 'http';\nimport * as mkdirp from 'mkdirp';\nimport { jo"
  },
  {
    "path": "packages/core/test/build/index.ts",
    "chars": 504,
    "preview": "import { resolve } from 'path';\nimport { existsSync } from 'fs';\n\nimport build from './build';\nimport copyJquery from '."
  },
  {
    "path": "packages/core/test/build/make_precompile.ts",
    "chars": 661,
    "preview": "import { readFileSync } from 'fs';\nimport { createContext, Script } from 'vm';\n\nexport default function makePrecompile(\n"
  },
  {
    "path": "packages/core/test/build/util.ts",
    "chars": 1003,
    "preview": "import { IncomingMessage } from \"http\";\nimport { pipeline } from \"stream\";\nimport * as https from \"https\";\n\nexport async"
  },
  {
    "path": "packages/core/test/fixtures/app.js",
    "chars": 2834,
    "preview": "var MyApp;\n(function() {\n  \"use strict\";\n  function renderEnd() {\n    performance.mark(\"renderEnd\");\n    requestAnimatio"
  },
  {
    "path": "packages/core/test/fixtures/index.html",
    "chars": 431,
    "preview": "<html>\n\n<head>\n  <title>Test Initial Render</title>\n  <script src=\"../jquery.min.js\"></script>\n  <script>\n    if ($) per"
  },
  {
    "path": "packages/core/test/fixtures/templates/application.hbs",
    "chars": 69,
    "preview": "<h1>Welcome To Ember</h1>\n<div style=\"{{{color}}}\">\n{{outlet}}\n</div>"
  },
  {
    "path": "packages/core/test/fixtures/templates/components/component-render.hbs",
    "chars": 60,
    "preview": "a: {{a}} b: {{b}} c: {{c}} d: {{d}} {{nested-component a=a}}"
  },
  {
    "path": "packages/core/test/fixtures/templates/components/nested-component.hbs",
    "chars": 8,
    "preview": "a: {{a}}"
  },
  {
    "path": "packages/core/test/fixtures/templates/index.hbs",
    "chars": 468,
    "preview": "<h2>Index</h2>\n<ul>\n  {{#each data.items as |item|}}\n  <li>{{buffer-render data=item.a}} {{buffer-render data=item.b}} {"
  },
  {
    "path": "packages/core/test/killTestServer.sh",
    "chars": 138,
    "preview": "set -e\nset -o pipefail\n\npid=$(ps -ef|grep -i \"test-server\"|sort -k5,5|awk '{print $2}'|head -1)\n#echo \"stop test server "
  },
  {
    "path": "packages/core/test/test-server.ts",
    "chars": 1468,
    "preview": "import * as express from 'express';\nimport { createParser } from 'dashdash';\nimport { Results, Option } from 'dashdash';"
  },
  {
    "path": "packages/core/test/test.ts",
    "chars": 7655,
    "preview": "import { writeFileSync, existsSync } from 'fs';\nimport mkdirp = require('mkdirp');\nimport { resolve, dirname, join } fro"
  },
  {
    "path": "packages/core/test/trace/trace-utils-test.ts",
    "chars": 2210,
    "preview": "import { assert } from 'chai';\nimport {\n  LCP_EVENT_NAME_ALIAS,\n  isTraceEndAtLCP,\n  isLCPEvent,\n  uniformLCPEventName,\n"
  },
  {
    "path": "packages/core/test/tsconfig.json",
    "chars": 239,
    "preview": "{\n  \"extends\": \"../tsconfig_base.json\",\n  \"compilerOptions\": {\n    \"outDir\": \"../dist/test\"\n  },\n  \"exclude\": [\"fixtures"
  },
  {
    "path": "packages/core/tsconfig.json",
    "chars": 125,
    "preview": "{\n  \"files\": [], // container only\n  \"references\": [\n    {\n      \"path\": \"src\"\n    },\n    {\n      \"path\": \"test\"\n    }\n "
  },
  {
    "path": "packages/core/tsconfig_base.json",
    "chars": 367,
    "preview": "{\n  \"$schema\": \"http://json.schemastore.org/tsconfig\",\n  \"compilerOptions\": {\n    \"composite\": true,\n    \"declaration\": "
  },
  {
    "path": "packages/har/LICENSE.md",
    "chars": 1328,
    "preview": "BSD 2-CLAUSE LICENSE\n\nCopyright 2019 LinkedIn Corporation and Contributors. All Rights Reserved.\n\nRedistribution and use"
  },
  {
    "path": "packages/har/README.md",
    "chars": 350,
    "preview": "# HAR JSON Typescript Interfaces\n\nProvides typing to parsed JSON from a HAR archive.\n\n## Example\n\n```ts\nimport { Archive"
  },
  {
    "path": "packages/har/package.json",
    "chars": 570,
    "preview": "{\n  \"name\": \"@tracerbench/har\",\n  \"version\": \"8.0.0\",\n  \"description\": \"HAR json typescript interfaces\",\n  \"keywords\": ["
  },
  {
    "path": "packages/har/scripts/generate.js",
    "chars": 1053,
    "preview": "#!/usr/bin/env node\nconst fs = require('fs');\nconst path = require('path');\nconst json2ts = require('json-schema-to-type"
  },
  {
    "path": "packages/har-remix/.eslintrc.js",
    "chars": 1999,
    "preview": "module.exports = {\n  root: true,\n  parser: '@typescript-eslint/parser',\n  parserOptions: {\n    sourceType: 'module'\n  },"
  },
  {
    "path": "packages/har-remix/LICENSE.md",
    "chars": 1328,
    "preview": "BSD 2-CLAUSE LICENSE\n\nCopyright 2019 LinkedIn Corporation and Contributors. All Rights Reserved.\n\nRedistribution and use"
  },
  {
    "path": "packages/har-remix/README.md",
    "chars": 1681,
    "preview": "# HAR-Remix\n\nHAR-Remix allows the offline serving of HTTP Archive (HAR) files.\n\nMany browsers (Chrome, Firefox) provide "
  },
  {
    "path": "packages/har-remix/package.json",
    "chars": 1416,
    "preview": "{\n  \"name\": \"har-remix\",\n  \"version\": \"8.0.0\",\n  \"description\": \"Server HAR archive with loose matching and hooks to alt"
  },
  {
    "path": "packages/har-remix/src/archive-server.ts",
    "chars": 4752,
    "preview": "import type { Archive, Entry } from '@tracerbench/har';\nimport { readFileSync } from 'fs';\nimport type { IncomingMessage"
  },
  {
    "path": "packages/har-remix/src/index.ts",
    "chars": 144,
    "preview": "import ArchiveServer from './archive-server';\n\nexport { ArchiveServer };\nexport type { Response, MapLike, ServerDelegate"
  },
  {
    "path": "packages/har-remix/src/interfaces.ts",
    "chars": 1923,
    "preview": "import type * as HAR from '@tracerbench/har';\nimport type { IncomingMessage, ServerResponse } from 'http';\n\nexport inter"
  },
  {
    "path": "packages/har-remix/tsconfig.json",
    "chars": 440,
    "preview": "{\n  \"$schema\": \"http://json.schemastore.org/tsconfig\",\n  \"compilerOptions\": {\n    \"composite\": true,\n    \"declaration\": "
  },
  {
    "path": "packages/stats/.editorconfig",
    "chars": 266,
    "preview": "root = true\n\n[*]\ncharset = utf-8\nindent_style = space\nindent_size = 2\nend_of_line = lf\ninsert_final_newline = true\ntrim_"
  },
  {
    "path": "packages/stats/.eslintignore",
    "chars": 141,
    "preview": "**/node_modules/\nbuild/\ndocs/\nlib/\ntmp/\nDEBUG/\n*.config.js\n\n/vendor/\n/node_modules/\n/dist/\n/temp/\n/tmp/\n/docs/\n/etc/\n/co"
  },
  {
    "path": "packages/stats/.eslintrc.js",
    "chars": 1847,
    "preview": "/* eslint-disable no-undef */\n/* eslint-disable filenames/match-regex */\n\nmodule.exports = {\n  root: true,\n  parser: '@t"
  },
  {
    "path": "packages/stats/.gitignore",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "packages/stats/.mocharc.json",
    "chars": 185,
    "preview": "{\n  \"require\": \"ts-node/register\",\n  \"extension\": [\"ts\"],\n  \"watch-files\": [\"test/**/*.test.ts\"],\n  \"recursive\": true,\n "
  },
  {
    "path": "packages/stats/.prettierrc",
    "chars": 53,
    "preview": "{\n  \"trailingComma\": \"none\",\n  \"singleQuote\": true\n}\n"
  },
  {
    "path": "packages/stats/LICENSE.md",
    "chars": 1328,
    "preview": "BSD 2-CLAUSE LICENSE\n\nCopyright 2019 LinkedIn Corporation and Contributors. All Rights Reserved.\n\nRedistribution and use"
  },
  {
    "path": "packages/stats/README.md",
    "chars": 2062,
    "preview": "## TracerBench: Automated Chrome Tracing For Benchmarking\n\n[![Build Status](https://travis-ci.org/TracerBench/tracerbenc"
  },
  {
    "path": "packages/stats/api-extractor.json",
    "chars": 14604,
    "preview": "/**\r\n * Config file for API Extractor.  For more info, please visit: https://api-extractor.com\r\n */\r\n{\r\n  \"$schema\": \"ht"
  },
  {
    "path": "packages/stats/etc/stats.api.md",
    "chars": 3760,
    "preview": "## API Report File for \"@tracerbench/stats\"\r\n\r\n> Do not edit this file. It is a report generated by [API Extractor](http"
  },
  {
    "path": "packages/stats/markdown/index.md",
    "chars": 229,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md)\r\n\r\n## API Referen"
  },
  {
    "path": "packages/stats/markdown/stats.cartesianproduct.md",
    "chars": 766,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.confidenceinterval.md",
    "chars": 747,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.convertmicrosecondstoms.md",
    "chars": 591,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.convertmstomicroseconds.md",
    "chars": 591,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.getwilcoxonranksumtest.md",
    "chars": 739,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.getwilcoxonsignedranktest.md",
    "chars": 680,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.iaspercentage.md",
    "chars": 378,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.iconfidenceinterval.md",
    "chars": 555,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.ioutliers.iqr.md",
    "chars": 304,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.ioutliers.loweroutlier.md",
    "chars": 340,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.ioutliers.md",
    "chars": 608,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.ioutliers.outliers.md",
    "chars": 326,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.ioutliers.upperoutlier.md",
    "chars": 340,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.isevenfiguresummary.md",
    "chars": 491,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.istatsoptions.confidencelevel.md",
    "chars": 409,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.istatsoptions.control.md",
    "chars": 338,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.istatsoptions.experiment.md",
    "chars": 350,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.istatsoptions.md",
    "chars": 710,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.istatsoptions.name.md",
    "chars": 324,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.md",
    "chars": 1966,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.roundfloatandconvertmicrosecondstoms.md",
    "chars": 668,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.stats._constructor_.md",
    "chars": 617,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.stats.buckets.md",
    "chars": 306,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.stats.confidenceinterval.md",
    "chars": 361,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.stats.confidenceintervals.md",
    "chars": 399,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.stats.control.md",
    "chars": 306,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.stats.controlsorted.md",
    "chars": 330,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  },
  {
    "path": "packages/stats/markdown/stats.stats.estimator.md",
    "chars": 312,
    "preview": "<!-- Do not edit this file. It is automatically generated by API Documenter. -->\r\n\r\n[Home](./index.md) &gt; [@tracerbenc"
  }
]

// ... and 56 more files (download for full content)