@luxonis/visualizer-protobuf 2.16.2 → 2.18.0

package/dist/tslib.es6-D98N6tjc.js

@@ -0,0 +1,4116 @@
+import { w as wrap } from './comlink-DHMAu6X7.js';
+import { useContext, useRef, useLayoutEffect, createContext, useReducer, useState, useCallback } from 'react';
+import { isParent, getLeaves, createRemoveUpdate, updateTree, getNodeAtPath } from 'react-mosaic-component';
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers-E-ZsRS8r.js';
+import { useTheme } from '@mui/material';
+import { k as isObjectLike, l as baseGetTag, S as Symbol$1, i as isArray, m as getNative, r as root, n as overArg, g as isPrototype, c as isArrayLike, p as arrayLikeKeys, M as MapCache, f as isArguments, t as toSource, q as Map$1, u as eq, U as Uint8Array$1, d as isBuffer, v as Stack, e as isTypedArray, h as isObject, w as isLength, j as isIndex, x as identity, y as baseFor, b as baseRest, a as isArrayLikeObject } from './isArrayLikeObject-Bytw9p-q.js';
+
+var dist = {};
+
+var Time = {};
+
+Object.defineProperty(Time, "__esModule", { value: true });
+
+var timeUtils = {};
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2018-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+Object.defineProperty(timeUtils, "__esModule", { value: true });
+timeUtils.areEqual = timeUtils.isGreaterThan = timeUtils.isLessThan = timeUtils.compare = timeUtils.isTimeInRangeInclusive = timeUtils.clampTime = timeUtils.fromMicros = timeUtils.fromMillis = timeUtils.toMillis = timeUtils.fromNanoSec = timeUtils.fromSec = timeUtils.toSec = timeUtils.toMicroSec = timeUtils.toNanoSec = timeUtils.subtract = timeUtils.add = timeUtils.fixTime = timeUtils.interpolate = timeUtils.percentOf = timeUtils.fromDate = timeUtils.toDate = timeUtils.fromRFC3339String = timeUtils.toRFC3339String = timeUtils.fromString = timeUtils.toString = timeUtils.isTime = void 0;
+/**
+ * Test if a given object matches the signature of { sec: number; nsec: number }
+ * @param obj Object to test
+ * @returns True if the object is equivalent to a Time object, otherwise false
+ */
+function isTime(obj) {
+    return (typeof obj === "object" &&
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        !!obj &&
+        "sec" in obj &&
+        "nsec" in obj &&
+        Object.getOwnPropertyNames(obj).length === 2);
+}
+timeUtils.isTime = isTime;
+/**
+ * Converts a Time to a string containing a floating point number of seconds
+ * @param stamp Time to convert
+ * @param allowNegative Allow negative times to be converted
+ * @returns String timestamp containing a floating point number of seconds
+ */
+function toString$1(stamp, allowNegative = false) {
+    if (!allowNegative && (stamp.sec < 0 || stamp.nsec < 0)) {
+        throw new Error(`Invalid negative time { sec: ${stamp.sec}, nsec: ${stamp.nsec} }`);
+    }
+    const sec = Math.floor(stamp.sec);
+    const nsec = Math.floor(stamp.nsec);
+    return `${sec}.${nsec.toFixed().padStart(9, "0")}`;
+}
+timeUtils.toString = toString$1;
+/**
+ * Parse fractional seconds (digits following a decimal separator ".") and interpret them as an
+ * integer number of nanoseconds. Because of the rounding behavior, this function may return 1e9 (a
+ * value that would be too large for the `nsec` field).
+ */
+function parseNanoseconds(digits) {
+    // There can be 9 digits of nanoseconds. If the fractional part is "1", we need to add eight
+    // zeros. Also, make sure we round to an integer if we need to _remove_ digits.
+    const digitsShort = 9 - digits.length;
+    return Math.round(parseInt(digits, 10) * 10 ** digitsShort);
+}
+/**
+ * Converts a string containing floating point number of seconds to a Time. We use a string because
+ * nanosecond precision cannot be stored in a 64-bit float for large values (e.g. UNIX timestamps).
+ * @param stamp UNIX timestamp containing a whole or floating point number of seconds
+ * @returns Time object on success, undefined on failure
+ */
+function fromString(stamp) {
+    if (/^\d+\.?$/.test(stamp)) {
+        // Whole number with optional "." at the end.
+        const sec = parseInt(stamp, 10);
+        return { sec: isNaN(sec) ? 0 : sec, nsec: 0 };
+    }
+    if (!/^\d+\.\d+$/.test(stamp)) {
+        // Not digits.digits -- invalid.
+        return undefined;
+    }
+    const partials = stamp.split(".");
+    if (partials.length === 0) {
+        return undefined;
+    }
+    const [first, second] = partials;
+    if (first == undefined || second == undefined) {
+        return undefined;
+    }
+    // It's possible we rounded to { sec: 1, nsec: 1e9 }, which is invalid, so fixTime.
+    const sec = parseInt(first, 10);
+    const nsec = parseNanoseconds(second);
+    return fixTime({ sec: isNaN(sec) ? 0 : sec, nsec });
+}
+timeUtils.fromString = fromString;
+/**
+ * Converts a Time to a string compatible with RFC3339/ISO8601. Similar to
+ * `toDate(stamp).toISOString()`, but with nanosecond precision.
+ * @param stamp Time to convert
+ */
+function toRFC3339String(stamp) {
+    if (stamp.sec < 0 || stamp.nsec < 0) {
+        throw new Error(`Invalid negative time { sec: ${stamp.sec}, nsec: ${stamp.nsec} }`);
+    }
+    if (stamp.nsec >= 1e9) {
+        throw new Error(`Invalid nanosecond value ${stamp.nsec}`);
+    }
+    const date = new Date(stamp.sec * 1000);
+    const year = date.getUTCFullYear();
+    const month = (date.getUTCMonth() + 1).toFixed().padStart(2, "0");
+    const day = date.getUTCDate().toFixed().padStart(2, "0");
+    const hour = date.getUTCHours().toFixed().padStart(2, "0");
+    const minute = date.getUTCMinutes().toFixed().padStart(2, "0");
+    const second = date.getUTCSeconds().toFixed().padStart(2, "0");
+    const nanosecond = stamp.nsec.toFixed().padStart(9, "0");
+    return `${year}-${month}-${day}T${hour}:${minute}:${second}.${nanosecond}Z`;
+}
+timeUtils.toRFC3339String = toRFC3339String;
+/**
+ * Parses a Time from a string compatible with a subset of ISO8601/RFC3339. Similar to
+ * `fromDate(new Date(string))`, but with nanosecond precision.
+ * @param stamp Time to convert
+ */
+function fromRFC3339String(stamp) {
+    const match = /^(\d{4,})-(\d\d)-(\d\d)[Tt](\d\d):(\d\d):(\d\d)(?:\.(\d+))?(?:[Zz]|([+-])(\d\d):(\d\d))$/.exec(stamp);
+    if (match == null) {
+        return undefined;
+    }
+    const [, year, month, day, hour, minute, second, frac, plusMinus, offHours, offMinutes] = match;
+    const offSign = plusMinus === "-" ? -1 : 1;
+    const utcMillis = Date.UTC(+year, +month - 1, +day, +hour - offSign * +(offHours ?? 0), +minute - offSign * +(offMinutes ?? 0), +second);
+    if (utcMillis % 1000 !== 0) {
+        return undefined;
+    }
+    // It's possible we rounded to { sec: 1, nsec: 1e9 }, which is invalid, so fixTime.
+    return fixTime({
+        sec: utcMillis / 1000,
+        nsec: frac != undefined ? parseNanoseconds(frac) : 0,
+    });
+}
+timeUtils.fromRFC3339String = fromRFC3339String;
+/**
+ * Convert a Time to a JavaScript Date object. NOTE: sub-millisecond precision is lost.
+ * @param stamp Time to convert
+ * @returns Date representing the given Time as accurately as it can
+ */
+function toDate(stamp) {
+    const { sec, nsec } = stamp;
+    return new Date(sec * 1000 + nsec / 1e6);
+}
+timeUtils.toDate = toDate;
+/**
+ * Conver a JavaScript Date object to a Time.
+ * @param date Date to convert
+ * @returns Time representing the given Date
+ */
+function fromDate(date) {
+    const millis = date.getTime();
+    const remainder = millis % 1000;
+    return { sec: Math.floor(millis / 1000), nsec: remainder * 1e6 };
+}
+timeUtils.fromDate = fromDate;
+/**
+ * Returns the fraction representing target's position in the range between start and end.
+ * e.g. start = { sec: 0 }, end = { sec: 10 }, target = { sec: 5 } = 0.5
+ * This is the reverse of the `interpolate()` method
+ * @param start Start timestamp of the interpolation range
+ * @param end End timestamp of the interpolation range
+ * @param target Timestamp that will be measured relative to the interpolation range
+ * @returns If target falls in between start and end (inclusive), it will be in the range [0.0-1.0].
+ *   Otherwise, it is unbounded
+ */
+function percentOf(start, end, target) {
+    const totalDuration = subtract(end, start);
+    const targetDuration = subtract(target, start);
+    return toSec(targetDuration) / toSec(totalDuration);
+}
+timeUtils.percentOf = percentOf;
+/**
+ * Linearly interpolate the range between start and end by a given fraction.
+ * e.g. start = { sec: 0 }, end = { sec: 10 }, fraction = 0.5 = { sec: 5 }
+ * This is the reverse of the `percentOf` method
+ * @param start Start timestamp of the interpolation range
+ * @param end End timestamp of the interpolation range
+ * @param fraction Percent to interpolate along the range
+ * @returns If fraction is in the range [0.0-1.0], the target will fall in between start and end\
+ *   (inclusive). Otherwise, it is unbounded
+ */
+function interpolate(start, end, fraction) {
+    const duration = subtract(end, start);
+    return add(start, fromSec(fraction * toSec(duration)));
+}
+timeUtils.interpolate = interpolate;
+/**
+ * Equivalent to fromNanoSec(toNanoSec(t)), but no chance of precision loss. nsec should be
+ * non-negative, and less than 1e9.
+ * @param t Potentially un-normalized time with the nsec (nanoseconds) value containing a value
+ *   higher than one second (1e9)
+ * @param allowNegative Allow negative times to be normalized
+ * @returns A normalized Time
+ */
+function fixTime(t, allowNegative = false) {
+    const durationNanos = t.nsec;
+    const secsFromNanos = Math.floor(durationNanos / 1e9);
+    const newSecs = t.sec + secsFromNanos;
+    const remainingDurationNanos = durationNanos % 1e9;
+    // use Math.abs here to prevent -0 when there is exactly 1 second of negative nanoseconds passed in
+    const newNanos = Math.abs(Math.sign(remainingDurationNanos) === -1
+        ? 1e9 + remainingDurationNanos
+        : remainingDurationNanos);
+    const result = { sec: newSecs, nsec: newNanos };
+    if ((!allowNegative && result.sec < 0) || result.nsec < 0) {
+        throw new Error(`Cannot normalize invalid time ${toString$1(result, true)}`);
+    }
+    return result;
+}
+timeUtils.fixTime = fixTime;
+/**
+ * Add two Times together
+ * @param param0 First Time
+ * @param param1 Second Time
+ * @returns A normalized representation of the two Time objects added together
+ */
+function add({ sec: sec1, nsec: nsec1 }, { sec: sec2, nsec: nsec2 }) {
+    return fixTime({ sec: sec1 + sec2, nsec: nsec1 + nsec2 });
+}
+timeUtils.add = add;
+/**
+ * Subtract one Time from another
+ * @param param0 First Time
+ * @param param1 Time to subtract from the first Time
+ * @returns A normalized representation of the second Time subtracted from the first
+ */
+function subtract({ sec: sec1, nsec: nsec1 }, { sec: sec2, nsec: nsec2 }) {
+    return fixTime({ sec: sec1 - sec2, nsec: nsec1 - nsec2 }, true);
+}
+timeUtils.subtract = subtract;
+/**
+ * Convert Time to an integer number of nanoseconds
+ * @param param0 Time to convert
+ * @returns A bigint integer number of nanoseconds
+ */
+function toNanoSec({ sec, nsec }) {
+    return BigInt(sec) * 1000000000n + BigInt(nsec);
+}
+timeUtils.toNanoSec = toNanoSec;
+/**
+ * Convert Time to a floating point number of microseconds
+ * @param param0 Time to convert
+ * @returns A floating point number of microseconds
+ */
+function toMicroSec({ sec, nsec }) {
+    return (sec * 1e9 + nsec) / 1000;
+}
+timeUtils.toMicroSec = toMicroSec;
+/**
+ * Convert Time to a floating point number of seconds
+ * @param param0 Time to convert
+ * @returns A floating point number of seconds
+ */
+function toSec({ sec, nsec }) {
+    return sec + nsec * 1e-9;
+}
+timeUtils.toSec = toSec;
+/**
+ * Convert a floating point number of seconds to Time
+ * @param value Number of seconds
+ * @returns Time object
+ */
+function fromSec(value) {
+    // From https://github.com/ros/roscpp_core/blob/indigo-devel/rostime/include/ros/time.h#L153
+    let sec = Math.trunc(value);
+    let nsec = Math.round((value - sec) * 1e9);
+    sec += Math.trunc(nsec / 1e9);
+    nsec %= 1e9;
+    return { sec, nsec };
+}
+timeUtils.fromSec = fromSec;
+/**
+ * Convert an integer number of nanoseconds to Time
+ * @param nsec Nanoseconds integer
+ * @returns Time object
+ */
+function fromNanoSec(nsec) {
+    // From https://github.com/ros/roscpp_core/blob/86720717c0e1200234cc0a3545a255b60fb541ec/rostime/include/ros/impl/time.h#L63
+    // and https://github.com/ros/roscpp_core/blob/7583b7d38c6e1c2e8623f6d98559c483f7a64c83/rostime/src/time.cpp#L536
+    //
+    // Note: BigInt(1e9) is slower than writing out the number
+    return { sec: Number(nsec / 1000000000n), nsec: Number(nsec % 1000000000n) };
+}
+timeUtils.fromNanoSec = fromNanoSec;
+/**
+ * Convert Time to an integer number of milliseconds
+ * @param time Time to convert
+ * @param roundUp Round up to nearest millisecond if true, otherwise round down. Defaults to true
+ * @returns Integer number of milliseconds
+ */
+function toMillis(time, roundUp = true) {
+    const secondsMillis = time.sec * 1e3;
+    const nsecMillis = time.nsec / 1e6;
+    return roundUp ? secondsMillis + Math.ceil(nsecMillis) : secondsMillis + Math.floor(nsecMillis);
+}
+timeUtils.toMillis = toMillis;
+/**
+ * Convert milliseconds to Time
+ * @param value Milliseconds number
+ * @returns Time object
+ */
+function fromMillis(value) {
+    let sec = Math.trunc(value / 1000);
+    let nsec = Math.round((value - sec * 1000) * 1e6);
+    sec += Math.trunc(nsec / 1e9);
+    nsec %= 1e9;
+    return { sec, nsec };
+}
+timeUtils.fromMillis = fromMillis;
+/**
+ * Convert microseconds to Time
+ * @param value Microseconds number
+ * @returns Time object
+ */
+function fromMicros(value) {
+    let sec = Math.trunc(value / 1e6);
+    let nsec = Math.round((value - sec * 1e6) * 1e3);
+    sec += Math.trunc(nsec / 1e9);
+    nsec %= 1e9;
+    return { sec, nsec };
+}
+timeUtils.fromMicros = fromMicros;
+/**
+ * Clamp a given time value in the range from start to end (inclusive)
+ * @param time Time to clamp
+ * @param start Start of the target range
+ * @param end End of the target range
+ * @returns Clamped Time
+ */
+function clampTime(time, start, end) {
+    if (compare(start, time) > 0) {
+        return { sec: start.sec, nsec: start.nsec };
+    }
+    if (compare(end, time) < 0) {
+        return { sec: end.sec, nsec: end.nsec };
+    }
+    return { sec: time.sec, nsec: time.nsec };
+}
+timeUtils.clampTime = clampTime;
+/**
+ * Test if a given time is inside a test range
+ * @param time Time to test
+ * @param start Start of the test range
+ * @param end End of the test range
+ * @returns True if time falls in between start and end (inclusive)
+ */
+function isTimeInRangeInclusive(time, start, end) {
+    if (compare(start, time) > 0 || compare(end, time) < 0) {
+        return false;
+    }
+    return true;
+}
+timeUtils.isTimeInRangeInclusive = isTimeInRangeInclusive;
+/**
+ * Comparison function for Time object that can be used for sorting
+ * @param left First Time to compare
+ * @param right Second Time to compare
+ * @returns A positive value if left is larger than right, a negative value if right is larger than
+ *   left, or zero if both times are equal
+ */
+function compare(left, right) {
+    const secDiff = left.sec - right.sec;
+    return secDiff !== 0 ? secDiff : left.nsec - right.nsec;
+}
+timeUtils.compare = compare;
+/**
+ * Returns true if the left time is less than the right time, otherwise false
+ * @param left Left side of comparison
+ * @param right Right side of comparison
+ * @returns Comparison result
+ */
+function isLessThan(left, right) {
+    return compare(left, right) < 0;
+}
+timeUtils.isLessThan = isLessThan;
+/**
+ * Returns true if the left time is greater than the right time, otherwise false
+ * @param left Left side of the comparison
+ * @param right Right side of the comparison
+ * @returns Comparison result
+ */
+function isGreaterThan(left, right) {
+    return compare(left, right) > 0;
+}
+timeUtils.isGreaterThan = isGreaterThan;
+/**
+ * Returns true if both times have the same number of seconds and nanoseconds
+ * @param left Left side of the comparison
+ * @param right Right side of the comparison
+ * @returns Equality result
+ */
+function areEqual(left, right) {
+    return left.sec === right.sec && left.nsec === right.nsec;
+}
+timeUtils.areEqual = areEqual;
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(Time, exports);
+	__exportStar(timeUtils, exports);
+	
+} (dist));
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+// logger channel -> logger
+const channels = new Map();
+const noop$1 = () => {};
+class Logger {
+  // default logger has an empty name
+  static default = new Logger("");
+  #name;
+
+  // all new loggers are created from the default logger
+  constructor(name) {
+    this.#name = name;
+    this.setLevel("debug");
+    channels.set(name, this);
+  }
+
+  // fully qualified name for the logger
+  name() {
+    return this.#name;
+  }
+
+  /**
+   * Return true if the level would display when logged by the logger
+   */
+  isLevelOn(level) {
+    switch (level) {
+      case "debug":
+        return this.debug !== noop$1;
+      case "info":
+        return this.info !== noop$1;
+      case "warn":
+        return this.warn !== noop$1;
+      case "error":
+        return this.error !== noop$1;
+    }
+    return false;
+  }
+
+  /**
+   *
+   * @returns the current log level
+   */
+  getLevel() {
+    if (this.debug !== noop$1) {
+      return "debug";
+    } else if (this.info !== noop$1) {
+      return "info";
+    } else if (this.warn !== noop$1) {
+      return "warn";
+    } else {
+      return "error";
+    }
+  }
+
+  /**
+   * Set the allowed log level. Any log calls with severity "below" this one will be ignored.
+   *
+   * i.e. setting a level of "warn" will ignore any "info" or "debug" logs
+   */
+  setLevel(level) {
+    this.debug = noop$1;
+    this.info = noop$1;
+    this.warn = noop$1;
+    this.error = noop$1;
+    switch (level) {
+      case "debug":
+        this.debug = console.debug.bind(global.console);
+        this.info = console.info.bind(global.console);
+        this.warn = console.warn.bind(global.console);
+        this.error = console.error.bind(global.console);
+        break;
+      case "info":
+        this.info = console.info.bind(global.console);
+        this.warn = console.warn.bind(global.console);
+        this.error = console.error.bind(global.console);
+        break;
+      case "warn":
+        this.warn = console.warn.bind(global.console);
+        this.error = console.error.bind(global.console);
+        break;
+      case "error":
+        this.error = console.error.bind(global.console);
+        break;
+    }
+  }
+  debug(..._args) {}
+  info(..._args) {}
+  warn(..._args) {}
+  error(..._args) {}
+
+  // create a new logger under this logger's namespace
+  getLogger(name) {
+    const shortName = name.replace(/^.+\.(asar|webpack)[\\/\\]/, "").replace(/^(\.\.\/)+/, "");
+    const channelName = this.#name.length > 0 ? `${this.#name}.${shortName}` : shortName;
+    const existing = channels.get(channelName);
+    if (existing) {
+      return existing;
+    }
+    const logger = new Logger(channelName);
+    channels.set(channelName, logger);
+    return logger;
+  }
+
+  // get all logging channels
+  channels() {
+    return Array.from(channels.values());
+  }
+}
+var Logger$1 = Logger.default;
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+const log$6 = Logger$1.getLogger("src/index.ts");
+/**
+ * Values of the contants below are a (more or less) informed guesses and not guaranteed to be accurate.
+ */
+const COMPRESSED_POINTER_SIZE = 4; // Pointers use 4 bytes (also on 64-bit systems) due to pointer compression
+const OBJECT_BASE_SIZE = 3 * COMPRESSED_POINTER_SIZE; // 3 compressed pointers
+// Arrays have an additional length property (1 pointer) and a backing store header (2 pointers)
+// See https://stackoverflow.com/a/70550693.
+const ARRAY_BASE_SIZE = OBJECT_BASE_SIZE + 3 * COMPRESSED_POINTER_SIZE;
+const TYPED_ARRAY_BASE_SIZE = 25 * COMPRESSED_POINTER_SIZE; // byteLength, byteOffset, ..., see https://stackoverflow.com/a/45808835
+const SMALL_INTEGER_SIZE = COMPRESSED_POINTER_SIZE; // Small integers (up to 31 bits), pointer tagging
+const HEAP_NUMBER_SIZE = 8 + 2 * COMPRESSED_POINTER_SIZE; // 4-byte map pointer + 8-byte payload + property pointer
+const MAX_NUM_FAST_PROPERTIES = 1020;
+
+/**
+ * Estimate the size in bytes of an arbitrary object or primitive.
+ * @param obj Object or primitive to estimate the size for
+ * @returns Estimated size in bytes
+ */
+function estimateObjectSize(obj) {
+  // catches null and undefined
+  // typeof null == "object"
+  if (obj == undefined) {
+    return SMALL_INTEGER_SIZE;
+  }
+  switch (typeof obj) {
+    case "undefined":
+    case "boolean":
+      {
+        return SMALL_INTEGER_SIZE;
+      }
+    case "number":
+      {
+        return Number.isInteger(obj) ? SMALL_INTEGER_SIZE : HEAP_NUMBER_SIZE;
+      }
+    case "bigint":
+      {
+        return HEAP_NUMBER_SIZE;
+      }
+    case "string":
+      {
+        // The string length is rounded up to the next multiple of 4.
+        return COMPRESSED_POINTER_SIZE + OBJECT_BASE_SIZE + Math.ceil(obj.length / 4) * 4;
+      }
+    case "object":
+      {
+        if (Array.isArray(obj)) {
+          return COMPRESSED_POINTER_SIZE + ARRAY_BASE_SIZE + Object.values(obj).reduce((acc, val) => acc + estimateObjectSize(val), 0);
+        } else if (ArrayBuffer.isView(obj)) {
+          return TYPED_ARRAY_BASE_SIZE + obj.byteLength;
+        } else if (obj instanceof Set) {
+          return COMPRESSED_POINTER_SIZE + OBJECT_BASE_SIZE + Array.from(obj.values()).reduce((acc, val) => acc + estimateObjectSize(val), 0);
+        } else if (obj instanceof Map) {
+          return COMPRESSED_POINTER_SIZE + OBJECT_BASE_SIZE + Array.from(obj.entries()).reduce((acc, [key, val]) => acc + estimateObjectSize(key) + estimateObjectSize(val), 0);
+        }
+        let propertiesSize = 0;
+        const numProps = Object.keys(obj).length;
+        if (numProps > MAX_NUM_FAST_PROPERTIES) {
+          // If there are too many properties, V8 stores Objects in dictionary mode (slow properties)
+          // with each object having a self-contained dictionary. This dictionary contains the key, value
+          // and details of properties. Below we estimate the size of this additional dictionary. Formula
+          // adapted from
+          // medium.com/@bpmxmqd/v8-engine-jsobject-structure-analysis-and-memory-optimization-ideas-be30cfcdcd16
+          const propertiesDictSize = 16 + 5 * 8 + 2 ** Math.ceil(Math.log2((numProps + 2) * 1.5)) * 3 * 4;
+          // In return, properties are no longer stored in the properties array, so we subtract that.
+          propertiesSize = propertiesDictSize - numProps * COMPRESSED_POINTER_SIZE;
+        }
+        const valuesSize = Object.values(obj).reduce((acc, val) => acc + estimateObjectSize(val), 0);
+        return OBJECT_BASE_SIZE + propertiesSize + valuesSize;
+      }
+    case "symbol":
+    case "function":
+      {
+        throw new Error(`Can't estimate size of type '${typeof obj}'`);
+      }
+  }
+  log$6.error(`Can't estimate size of type '${typeof obj}'`);
+  return SMALL_INTEGER_SIZE;
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+/// <reference types="@webgpu/types" />
+function uint8ArrayToUint16Array(uint8Array) {
+  if (uint8Array.length % 2 !== 0) {
+    throw new Error("Uint8Array length must be a multiple of 2 for conversion to Uint16Array");
+  }
+  const uint16Array = new Uint16Array(uint8Array.length / 2);
+  for (let i = 0; i < uint16Array.length; i++) {
+    const lowByte = uint8Array[i * 2];
+    const highByte = uint8Array[i * 2 + 1];
+
+    // eslint-disable-next-line @foxglove/strict-equality
+    if (highByte === undefined || lowByte === undefined) {
+      throw new Error("Invalid data in uint8Array");
+    }
+    uint16Array[i] = highByte << 8 | lowByte;
+  }
+  return uint16Array;
+}
+const worker = new Worker(new URL("i420ToRgbaToPoitcloud.worker-CzFC0VI1.js", import.meta.url), {
+  type: "module"
+});
+const workerApi = wrap(worker);
+async function i420ToRgbaToPointcloudWorker(i420Data, i420Width, i420Height, depthWidth, depthHeight, data) {
+  return await workerApi.i420ToRgbaToPointcloud(i420Data, i420Width, i420Height, depthWidth, depthHeight, data);
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+const globalWithHandler = global;
+
+/**
+ * Report an error that has escaped past normal error-handling flows in the app and should be
+ * triaged and diagnosed.
+ */
+function reportError(error) {
+  globalWithHandler.foxgloveStudioReportErrorFn?.(error);
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2019-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+
+class AppError extends Error {
+  constructor(details, extraInfo) {
+    super();
+    this.details = details;
+    this.extraInfo = extraInfo;
+    this.name = "AppError";
+    this.message = "";
+    if (details instanceof Error) {
+      this.message = details.stack ?? details.message;
+    } else if (typeof details === "string") {
+      this.message = details;
+    }
+    if (extraInfo != undefined) {
+      // If `extraInfo` was passed via a componentDidCatch:
+      // https://reactjs.org/docs/react-component.html#componentdidcatch
+      if (extraInfo.componentStack != undefined) {
+        this.message += `\n\n${extraInfo.componentStack}`;
+      } else {
+        try {
+          const stringifiedExtraInfo = JSON.stringify(extraInfo);
+          this.message += `\n\n${stringifiedExtraInfo}`;
+        } catch (e) {
+          this.message += `\n\n[ Either cyclic object or object with BigInt(s) ]`;
+        }
+      }
+    }
+    if (this.message === "") {
+      this.message = "Unknown Error";
+    }
+  }
+}
+
+/** `Object#toString` result references. */
+var symbolTag$1 = '[object Symbol]';
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return typeof value == 'symbol' ||
+    (isObjectLike(value) && baseGetTag(value) == symbolTag$1);
+}
+
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap(array, iteratee) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      result = Array(length);
+
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+
+/** Used as references for various `Number` constants. */
+var INFINITY$2 = 1 / 0;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : undefined,
+    symbolToString = symbolProto$1 ? symbolProto$1.toString : undefined;
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isArray(value)) {
+    // Recursively convert values (susceptible to call stack limits).
+    return arrayMap(value, baseToString) + '';
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = (value + '');
+  return (result == '0' && (1 / value) == -INFINITY$2) ? '-0' : result;
+}
+
+/* Built-in method references that are verified to be native. */
+var WeakMap = getNative(root, 'WeakMap');
+
+/**
+ * This method returns `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.3.0
+ * @category Util
+ * @example
+ *
+ * _.times(2, _.noop);
+ * // => [undefined, undefined]
+ */
+function noop() {
+  // No operation performed.
+}
+
+/**
+ * The base implementation of `_.findIndex` and `_.findLastIndex` without
+ * support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {number} fromIndex The index to search from.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+  var length = array.length,
+      index = fromIndex + (-1);
+
+  while ((++index < length)) {
+    if (predicate(array[index], index, array)) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+/**
+ * The base implementation of `_.isNaN` without support for number objects.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
+ */
+function baseIsNaN(value) {
+  return value !== value;
+}
+
+/**
+ * A specialized version of `_.indexOf` which performs strict equality
+ * comparisons of values, i.e. `===`.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function strictIndexOf(array, value, fromIndex) {
+  var index = fromIndex - 1,
+      length = array.length;
+
+  while (++index < length) {
+    if (array[index] === value) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+/**
+ * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseIndexOf(array, value, fromIndex) {
+  return value === value
+    ? strictIndexOf(array, value, fromIndex)
+    : baseFindIndex(array, baseIsNaN, fromIndex);
+}
+
+/**
+ * A specialized version of `_.includes` for arrays without support for
+ * specifying an index to search from.
+ *
+ * @private
+ * @param {Array} [array] The array to inspect.
+ * @param {*} target The value to search for.
+ * @returns {boolean} Returns `true` if `target` is found, else `false`.
+ */
+function arrayIncludes(array, value) {
+  var length = array == null ? 0 : array.length;
+  return !!length && baseIndexOf(array, value, 0) > -1;
+}
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeKeys = overArg(Object.keys, Object);
+
+/** Used for built-in method references. */
+var objectProto$3 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+
+/**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$2.call(object, key) && key != 'constructor') {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+/** Used to match property names within property paths. */
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+    reIsPlainProp = /^\w*$/;
+
+/**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+function isKey(value, object) {
+  if (isArray(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+      value == null || isSymbol(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+    (object != null && value in Object(object));
+}
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+function memoize(func, resolver) {
+  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments,
+        key = resolver ? resolver.apply(this, args) : args[0],
+        cache = memoized.cache;
+
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache);
+  return memoized;
+}
+
+// Expose `MapCache`.
+memoize.Cache = MapCache;
+
+/** Used as the maximum memoize cache size. */
+var MAX_MEMOIZE_SIZE = 500;
+
+/**
+ * A specialized version of `_.memoize` which clears the memoized function's
+ * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+ *
+ * @private
+ * @param {Function} func The function to have its output memoized.
+ * @returns {Function} Returns the new memoized function.
+ */
+function memoizeCapped(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+
+  var cache = result.cache;
+  return result;
+}
+
+/** Used to match property names within property paths. */
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+/** Used to match backslashes in property paths. */
+var reEscapeChar = /\\(\\)?/g;
+
+/**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+var stringToPath = memoizeCapped(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46 /* . */) {
+    result.push('');
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
+  });
+  return result;
+});
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString(value) {
+  return value == null ? '' : baseToString(value);
+}
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {Array} Returns the cast property path array.
+ */
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+
+/** Used as references for various `Number` constants. */
+var INFINITY$1 = 1 / 0;
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey(value) {
+  if (typeof value == 'string' || isSymbol(value)) {
+    return value;
+  }
+  var result = (value + '');
+  return (result == '0' && (1 / value) == -INFINITY$1) ? '-0' : result;
+}
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet(object, path) {
+  path = castPath(path, object);
+
+  var index = 0,
+      length = path.length;
+
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return (index && index == length) ? object : undefined;
+}
+
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */
+function get(object, path, defaultValue) {
+  var result = object == null ? undefined : baseGet(object, path);
+  return result === undefined ? defaultValue : result;
+}
+
+/**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+function arrayPush(array, values) {
+  var index = -1,
+      length = values.length,
+      offset = array.length;
+
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+
+/** Built-in value references. */
+var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : undefined;
+
+/**
+ * Checks if `value` is a flattenable `arguments` object or array.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
+ */
+function isFlattenable(value) {
+  return isArray(value) || isArguments(value) ||
+    !!(spreadableSymbol && value && value[spreadableSymbol]);
+}
+
+/**
+ * The base implementation of `_.flatten` with support for restricting flattening.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {number} depth The maximum recursion depth.
+ * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+ * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
+ * @param {Array} [result=[]] The initial result value.
+ * @returns {Array} Returns the new flattened array.
+ */
+function baseFlatten(array, depth, predicate, isStrict, result) {
+  var index = -1,
+      length = array.length;
+
+  predicate || (predicate = isFlattenable);
+  result || (result = []);
+
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value)) {
+      {
+        arrayPush(result, value);
+      }
+    } else if (!isStrict) {
+      result[result.length] = value;
+    }
+  }
+  return result;
+}
+
+/**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+function arrayFilter(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      resIndex = 0,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+
+/**
+ * This method returns a new empty array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {Array} Returns the new empty array.
+ * @example
+ *
+ * var arrays = _.times(2, _.stubArray);
+ *
+ * console.log(arrays);
+ * // => [[], []]
+ *
+ * console.log(arrays[0] === arrays[1]);
+ * // => false
+ */
+function stubArray() {
+  return [];
+}
+
+/** Used for built-in method references. */
+var objectProto$2 = Object.prototype;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto$2.propertyIsEnumerable;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Creates an array of the own enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+
+/**
+ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+ * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @param {Function} symbolsFunc The function to get the symbols of `object`.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+
+/**
+ * Creates an array of own enumerable property names and symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+
+/* Built-in method references that are verified to be native. */
+var DataView$1 = getNative(root, 'DataView');
+
+/* Built-in method references that are verified to be native. */
+var Promise$1 = getNative(root, 'Promise');
+
+/* Built-in method references that are verified to be native. */
+var Set$1 = getNative(root, 'Set');
+
+/** `Object#toString` result references. */
+var mapTag$1 = '[object Map]',
+    objectTag$1 = '[object Object]',
+    promiseTag = '[object Promise]',
+    setTag$1 = '[object Set]',
+    weakMapTag = '[object WeakMap]';
+
+var dataViewTag$1 = '[object DataView]';
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView$1),
+    mapCtorString = toSource(Map$1),
+    promiseCtorString = toSource(Promise$1),
+    setCtorString = toSource(Set$1),
+    weakMapCtorString = toSource(WeakMap);
+
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+var getTag = baseGetTag;
+
+// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+if ((DataView$1 && getTag(new DataView$1(new ArrayBuffer(1))) != dataViewTag$1) ||
+    (Map$1 && getTag(new Map$1) != mapTag$1) ||
+    (Promise$1 && getTag(Promise$1.resolve()) != promiseTag) ||
+    (Set$1 && getTag(new Set$1) != setTag$1) ||
+    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+  getTag = function(value) {
+    var result = baseGetTag(value),
+        Ctor = result == objectTag$1 ? value.constructor : undefined,
+        ctorString = Ctor ? toSource(Ctor) : '';
+
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString: return dataViewTag$1;
+        case mapCtorString: return mapTag$1;
+        case promiseCtorString: return promiseTag;
+        case setCtorString: return setTag$1;
+        case weakMapCtorString: return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+
+/**
+ * Creates an array with all falsey values removed. The values `false`, `null`,
+ * `0`, `""`, `undefined`, and `NaN` are falsey.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to compact.
+ * @returns {Array} Returns the new array of filtered values.
+ * @example
+ *
+ * _.compact([0, 1, false, 2, '', 3]);
+ * // => [1, 2, 3]
+ */
+function compact(array) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      resIndex = 0,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+    if (value) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+
+/**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+  var index = -1,
+      length = values == null ? 0 : values.length;
+
+  this.__data__ = new MapCache;
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ */
+function arraySome(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Checks if a `cache` value for `key` exists.
+ *
+ * @private
+ * @param {Object} cache The cache to query.
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG$5 = 1,
+    COMPARE_UNORDERED_FLAG$3 = 2;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `array` and `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5,
+      arrLength = array.length,
+      othLength = other.length;
+
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  // Check that cyclic values are equal.
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1,
+      result = true,
+      seen = (bitmask & COMPARE_UNORDERED_FLAG$3) ? new SetCache : undefined;
+
+  stack.set(array, other);
+  stack.set(other, array);
+
+  // Ignore non-index properties.
+  while (++index < arrLength) {
+    var arrValue = array[index],
+        othValue = other[index];
+
+    if (customizer) {
+      var compared = isPartial
+        ? customizer(othValue, arrValue, index, other, array, stack)
+        : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== undefined) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    // Recursively compare arrays (susceptible to call stack limits).
+    if (seen) {
+      if (!arraySome(other, function(othValue, othIndex) {
+            if (!cacheHas(seen, othIndex) &&
+                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+              return seen.push(othIndex);
+            }
+          })) {
+        result = false;
+        break;
+      }
+    } else if (!(
+          arrValue === othValue ||
+            equalFunc(arrValue, othValue, bitmask, customizer, stack)
+        )) {
+      result = false;
+      break;
+    }
+  }
+  stack['delete'](array);
+  stack['delete'](other);
+  return result;
+}
+
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+function mapToArray(map) {
+  var index = -1,
+      result = Array(map.size);
+
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+function setToArray(set) {
+  var index = -1,
+      result = Array(set.size);
+
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG$4 = 1,
+    COMPARE_UNORDERED_FLAG$2 = 2;
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]';
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined,
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if ((object.byteLength != other.byteLength) ||
+          (object.byteOffset != other.byteOffset)) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+
+    case arrayBufferTag:
+      if ((object.byteLength != other.byteLength) ||
+          !equalFunc(new Uint8Array$1(object), new Uint8Array$1(other))) {
+        return false;
+      }
+      return true;
+
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      // Coerce booleans to `1` or `0` and dates to milliseconds.
+      // Invalid dates are coerced to `NaN`.
+      return eq(+object, +other);
+
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+
+    case regexpTag:
+    case stringTag:
+      // Coerce regexes to strings and treat strings, primitives and objects,
+      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+      // for more details.
+      return object == (other + '');
+
+    case mapTag:
+      var convert = mapToArray;
+
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
+      convert || (convert = setToArray);
+
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      // Assume cyclic values are equal.
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG$2;
+
+      // Recursively compare objects (susceptible to call stack limits).
+      stack.set(object, other);
+      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack['delete'](object);
+      return result;
+
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG$3 = 1;
+
+/** Used for built-in method references. */
+var objectProto$1 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3,
+      objProps = getAllKeys(object),
+      objLength = objProps.length,
+      othProps = getAllKeys(other),
+      othLength = othProps.length;
+
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) {
+      return false;
+    }
+  }
+  // Check that cyclic values are equal.
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key],
+        othValue = other[key];
+
+    if (customizer) {
+      var compared = isPartial
+        ? customizer(othValue, objValue, key, other, object, stack)
+        : customizer(objValue, othValue, key, object, other, stack);
+    }
+    // Recursively compare objects (susceptible to call stack limits).
+    if (!(compared === undefined
+          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
+          : compared
+        )) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == 'constructor');
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor,
+        othCtor = other.constructor;
+
+    // Non `Object` object instances with different constructors are not equal.
+    if (objCtor != othCtor &&
+        ('constructor' in object && 'constructor' in other) &&
+        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
+          typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack['delete'](object);
+  stack['delete'](other);
+  return result;
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG$2 = 1;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object),
+      othIsArr = isArray(other),
+      objTag = objIsArr ? arrayTag : getTag(object),
+      othTag = othIsArr ? arrayTag : getTag(other);
+
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+
+  var objIsObj = objTag == objectTag,
+      othIsObj = othTag == objectTag,
+      isSameTag = objTag == othTag;
+
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack);
+    return (objIsArr || isTypedArray(object))
+      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object,
+          othUnwrapped = othIsWrapped ? other.value() : other;
+
+      stack || (stack = new Stack);
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack);
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+
+/**
+ * The base implementation of `_.isEqual` which supports partial comparisons
+ * and tracks traversed objects.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {boolean} bitmask The bitmask flags.
+ *  1 - Unordered comparison
+ *  2 - Partial comparison
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG$1 = 1,
+    COMPARE_UNORDERED_FLAG$1 = 2;
+
+/**
+ * The base implementation of `_.isMatch` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Array} matchData The property names, values, and compare flags to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ */
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length,
+      length = index;
+
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if ((data[2])
+          ? data[1] !== object[data[0]]
+          : !(data[0] in object)
+        ) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0],
+        objValue = object[key],
+        srcValue = data[1];
+
+    if (data[2]) {
+      if (objValue === undefined && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack;
+      var result; 
+      if (!(result === undefined
+            ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack)
+            : result
+          )) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+/**
+ * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` if suitable for strict
+ *  equality comparisons, else `false`.
+ */
+function isStrictComparable(value) {
+  return value === value && !isObject(value);
+}
+
+/**
+ * Gets the property names, values, and compare flags of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the match data of `object`.
+ */
+function getMatchData(object) {
+  var result = keys(object),
+      length = result.length;
+
+  while (length--) {
+    var key = result[length],
+        value = object[key];
+
+    result[length] = [key, value, isStrictComparable(value)];
+  }
+  return result;
+}
+
+/**
+ * A specialized version of `matchesProperty` for source values suitable
+ * for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue &&
+      (srcValue !== undefined || (key in Object(object)));
+  };
+}
+
+/**
+ * The base implementation of `_.matches` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property values to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatches(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+
+/**
+ * The base implementation of `_.hasIn` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+
+/**
+ * Checks if `path` exists on `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @param {Function} hasFunc The function to check properties.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ */
+function hasPath(object, path, hasFunc) {
+  path = castPath(path, object);
+
+  var index = -1,
+      length = path.length,
+      result = false;
+
+  while (++index < length) {
+    var key = toKey(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex(key, length) &&
+    (isArray(object) || isArguments(object));
+}
+
+/**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */
+function hasIn(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
+ *
+ * @private
+ * @param {string} path The path of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get(object, path);
+    return (objValue === undefined && objValue === srcValue)
+      ? hasIn(object, path)
+      : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+
+/**
+ * The base implementation of `_.property` without support for deep paths.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? undefined : object[key];
+  };
+}
+
+/**
+ * A specialized version of `baseProperty` which supports deep paths.
+ *
+ * @private
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyDeep(path) {
+  return function(object) {
+    return baseGet(object, path);
+  };
+}
+
+/**
+ * Creates a function that returns the value at `path` of a given object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ * @example
+ *
+ * var objects = [
+ *   { 'a': { 'b': 2 } },
+ *   { 'a': { 'b': 1 } }
+ * ];
+ *
+ * _.map(objects, _.property('a.b'));
+ * // => [2, 1]
+ *
+ * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
+ * // => [1, 2]
+ */
+function property(path) {
+  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+
+/**
+ * The base implementation of `_.iteratee`.
+ *
+ * @private
+ * @param {*} [value=_.identity] The value to convert to an iteratee.
+ * @returns {Function} Returns the iteratee.
+ */
+function baseIteratee(value) {
+  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+  if (typeof value == 'function') {
+    return value;
+  }
+  if (value == null) {
+    return identity;
+  }
+  if (typeof value == 'object') {
+    return isArray(value)
+      ? baseMatchesProperty(value[0], value[1])
+      : baseMatches(value);
+  }
+  return property(value);
+}
+
+/**
+ * The base implementation of `_.forOwn` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwn(object, iteratee) {
+  return object && baseFor(object, iteratee, keys);
+}
+
+/**
+ * Creates a `baseEach` or `baseEachRight` function.
+ *
+ * @private
+ * @param {Function} eachFunc The function to iterate over a collection.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseEach(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length,
+        index = -1,
+        iterable = Object(collection);
+
+    while ((++index < length)) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+
+/**
+ * The base implementation of `_.forEach` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEach = createBaseEach(baseForOwn);
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE$1 = 200;
+
+/**
+ * The base implementation of methods like `_.difference` without support
+ * for excluding multiple arrays or iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Array} values The values to exclude.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of filtered values.
+ */
+function baseDifference(array, values, iteratee, comparator) {
+  var index = -1,
+      includes = arrayIncludes,
+      isCommon = true,
+      length = array.length,
+      result = [],
+      valuesLength = values.length;
+
+  if (!length) {
+    return result;
+  }
+  if (values.length >= LARGE_ARRAY_SIZE$1) {
+    includes = cacheHas;
+    isCommon = false;
+    values = new SetCache(values);
+  }
+  outer:
+  while (++index < length) {
+    var value = array[index],
+        computed = value ;
+
+    value = (value !== 0) ? value : 0;
+    if (isCommon && computed === computed) {
+      var valuesIndex = valuesLength;
+      while (valuesIndex--) {
+        if (values[valuesIndex] === computed) {
+          continue outer;
+        }
+      }
+      result.push(value);
+    }
+    else if (!includes(values, computed, comparator)) {
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+/**
+ * The base implementation of `_.map` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function baseMap(collection, iteratee) {
+  var index = -1,
+      result = isArrayLike(collection) ? Array(collection.length) : [];
+
+  baseEach(collection, function(value, key, collection) {
+    result[++index] = iteratee(value, key, collection);
+  });
+  return result;
+}
+
+/**
+ * Creates an array of values by running each element in `collection` thru
+ * `iteratee`. The iteratee is invoked with three arguments:
+ * (value, index|key, collection).
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like
+ * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
+ *
+ * The guarded methods are:
+ * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
+ * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
+ * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
+ * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ * @example
+ *
+ * function square(n) {
+ *   return n * n;
+ * }
+ *
+ * _.map([4, 8], square);
+ * // => [16, 64]
+ *
+ * _.map({ 'a': 4, 'b': 8 }, square);
+ * // => [16, 64] (iteration order is not guaranteed)
+ *
+ * var users = [
+ *   { 'user': 'barney' },
+ *   { 'user': 'fred' }
+ * ];
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.map(users, 'user');
+ * // => ['barney', 'fred']
+ */
+function map(collection, iteratee) {
+  var func = isArray(collection) ? arrayMap : baseMap;
+  return func(collection, baseIteratee(iteratee));
+}
+
+/**
+ * Creates a flattened array of values by running each element in `collection`
+ * thru `iteratee` and flattening the mapped results. The iteratee is invoked
+ * with three arguments: (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * function duplicate(n) {
+ *   return [n, n];
+ * }
+ *
+ * _.flatMap([1, 2], duplicate);
+ * // => [1, 1, 2, 2]
+ */
+function flatMap(collection, iteratee) {
+  return baseFlatten(map(collection, iteratee));
+}
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/**
+ * Creates a set object of `values`.
+ *
+ * @private
+ * @param {Array} values The values to add to the set.
+ * @returns {Object} Returns the new set.
+ */
+var createSet = !(Set$1 && (1 / setToArray(new Set$1([,-0]))[1]) == INFINITY) ? noop : function(values) {
+  return new Set$1(values);
+};
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/**
+ * The base implementation of `_.uniqBy` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ */
+function baseUniq(array, iteratee, comparator) {
+  var index = -1,
+      includes = arrayIncludes,
+      length = array.length,
+      isCommon = true,
+      result = [],
+      seen = result;
+
+  if (length >= LARGE_ARRAY_SIZE) {
+    var set = createSet(array);
+    if (set) {
+      return setToArray(set);
+    }
+    isCommon = false;
+    includes = cacheHas;
+    seen = new SetCache;
+  }
+  else {
+    seen = result;
+  }
+  outer:
+  while (++index < length) {
+    var value = array[index],
+        computed = value;
+
+    value = (value !== 0) ? value : 0;
+    if (isCommon && computed === computed) {
+      var seenIndex = seen.length;
+      while (seenIndex--) {
+        if (seen[seenIndex] === computed) {
+          continue outer;
+        }
+      }
+      result.push(value);
+    }
+    else if (!includes(seen, computed, comparator)) {
+      if (seen !== result) {
+        seen.push(computed);
+      }
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+/**
+ * Creates a duplicate-free version of an array, using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons, in which only the first occurrence of each element
+ * is kept. The order of result values is determined by the order they occur
+ * in the array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ *
+ * _.uniq([2, 1, 2]);
+ * // => [2, 1]
+ */
+function uniq(array) {
+  return (array && array.length) ? baseUniq(array) : [];
+}
+
+/**
+ * Creates an array excluding all given values using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * **Note:** Unlike `_.pull`, this method returns a new array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {...*} [values] The values to exclude.
+ * @returns {Array} Returns the new array of filtered values.
+ * @see _.difference, _.xor
+ * @example
+ *
+ * _.without([2, 1, 2, 3], 1, 2);
+ * // => [3]
+ */
+var without = baseRest(function(array, values) {
+  return isArrayLikeObject(array)
+    ? baseDifference(array, values)
+    : [];
+});
+
+/**
+ * The base implementation of methods like `_.xor`, without support for
+ * iteratee shorthands, that accepts an array of arrays to inspect.
+ *
+ * @private
+ * @param {Array} arrays The arrays to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of values.
+ */
+function baseXor(arrays, iteratee, comparator) {
+  var length = arrays.length;
+  if (length < 2) {
+    return length ? baseUniq(arrays[0]) : [];
+  }
+  var index = -1,
+      result = Array(length);
+
+  while (++index < length) {
+    var array = arrays[index],
+        othIndex = -1;
+
+    while (++othIndex < length) {
+      if (othIndex != index) {
+        result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
+      }
+    }
+  }
+  return baseUniq(baseFlatten(result), iteratee, comparator);
+}
+
+/**
+ * Creates an array of unique values that is the
+ * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
+ * of the given arrays. The order of result values is determined by the order
+ * they occur in the arrays.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of filtered values.
+ * @see _.difference, _.without
+ * @example
+ *
+ * _.xor([2, 1], [2, 3]);
+ * // => [1, 3]
+ */
+var xor = baseRest(function(arrays) {
+  return baseXor(arrayFilter(arrays, isArrayLikeObject));
+});
+
+//
+
+var shallowequal = function shallowEqual(objA, objB, compare, compareContext) {
+  var ret = compare ? compare.call(compareContext, objA, objB) : void 0;
+
+  if (ret !== void 0) {
+    return !!ret;
+  }
+
+  if (objA === objB) {
+    return true;
+  }
+
+  if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) {
+    return false;
+  }
+
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+
+  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
+
+  // Test for A's keys different from B.
+  for (var idx = 0; idx < keysA.length; idx++) {
+    var key = keysA[idx];
+
+    if (!bHasOwnProperty(key)) {
+      return false;
+    }
+
+    var valueA = objA[key];
+    var valueB = objB[key];
+
+    ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
+
+    if (ret === false || (ret === void 0 && valueA !== valueB)) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+var shallowequal$1 = /*@__PURE__*/getDefaultExportFromCjs(shallowequal);
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2018-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+
+function useGuaranteedContext(contextType, debugContextName) {
+  const context = useContext(contextType);
+  if (context == undefined) {
+    throw new Error(`useGuaranteedContext got null for contextType${""}`);
+  }
+  return context;
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+const log$5 = Logger$1.getLogger("src/index.ts");
+const useMustNotChangeImpl = value => {
+  const valueRef = useRef(value);
+  if (valueRef.current !== value) {
+    log$5.error("Value must not change", valueRef.current);
+  }
+  valueRef.current = value;
+};
+const noOpImpl$1 = () => {};
+
+/**
+ * useMustNotChange throws if the value provided as the first argument ever changes.
+ *
+ * Note: In production builds this hook is a no-op.
+ *
+ */
+const useMustNotChange = process.env.NODE_ENV !== "development" ? noOpImpl$1 : useMustNotChangeImpl;
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+/** Continues to return the same instance as long as shallow equality is maintained. */
+function useShallowMemo(value) {
+  const ref = useRef(value);
+  if (shallowequal$1(value, ref.current)) {
+    return ref.current;
+  }
+  ref.current = value;
+  return value;
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+const log$4 = Logger$1.getLogger("src/index.ts");
+const noOpImpl = () => {};
+function useValueChangedDebugLogImpl(value, msg) {
+  const prevValue = useRef(value);
+  if (prevValue.current !== value) {
+    log$4.debug(`value changed: ${msg}`);
+  }
+  useLayoutEffect(() => {
+    prevValue.current = value;
+  });
+}
+
+/**
+ * useValueChangedDebugLog logs `msg` if `value` changes
+ *
+ * Note: In production builds this hook is a no-op.
+ */
+const useValueChangedDebugLog = process.env.NODE_ENV !== "development" && process.env.NODE_ENV !== "test" ? noOpImpl : useValueChangedDebugLogImpl;
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+const log$3 = Logger$1.getLogger("src/index.ts");
+
+// useWarnImmediateReRender will warn if the component re-renders before the next animation frame
+// This typically indicates that the component state is changing in rapid succession and more
+// work is being done than necessary.
+//
+// Note: This detects state change triggers in useLayoutEffect. It does not detect state changes from
+// useEffect which run on the next animation frame.
+process.env.NODE_ENV !== "development" ? () => {} : () => {
+  const renderedRef = useRef(false);
+  useLayoutEffect(() => {
+    if (renderedRef.current) {
+      log$3.warn("Component re-rendered immediately");
+    }
+    renderedRef.current = true;
+    const raf = requestAnimationFrame(() => {
+      renderedRef.current = false;
+    });
+    return () => {
+      cancelAnimationFrame(raf);
+    };
+  });
+};
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+Logger$1.getLogger("src/index.ts");
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+const log$2 = Logger$1.getLogger("src/index.ts");
+function selectWithUnstableIdentityWarning(value, selector) {
+  const result = selector(value);
+  if (process.env.NODE_ENV === "development") {
+    const secondResult = selector(value);
+    if (result !== secondResult) {
+      log$2.warn(`Selector ${selector.toString()} produced different values for the same input.
+  This will cause unecesessery re-renders of your component.`);
+    }
+    return secondResult;
+  }
+  return result;
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2018-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+
+
+// Call _warn_ if a given value changes twice within 200 ms
+function useShouldNotChangeOften(value, warn) {
+  const prev = useRef(value);
+  const prevPrev = useRef(value);
+  const lastTime = useRef(Date.now());
+  if (value !== prev.current && prev.current !== prevPrev.current && Date.now() - lastTime.current < 200) {
+    warn();
+  }
+  prevPrev.current = prev.current;
+  prev.current = value;
+  lastTime.current = Date.now();
+  return value;
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2019-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+
+/**
+ * filterMap creates a new array populated with the results of calling a provided function on every
+ * element in the calling array. Results which resolve to a javascript "false" value are discarded
+ * from the array.
+ *
+ * This is a more efficient version of [...values].map(mapFn).filter(Boolean) that avoids two
+ * iterations of the array.
+ */
+function filterMap(values, mapFn) {
+  const results = [];
+  let index = 0;
+  for (const item of values) {
+    const mappedItem = mapFn(item, index++);
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (mappedItem) {
+      results.push(mappedItem);
+    }
+  }
+  return results;
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2018-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+function useJsonTreeTheme() {
+  const {
+    palette: {
+      mode,
+      text
+    }
+  } = useTheme();
+  return {
+    dark: {
+      base00: "transparent",
+      // bg
+      base0B: "#ffa657",
+      // string & date, item string
+      base09: "#7ee787",
+      // # & boolean
+      base07: "#79c0ff",
+      // text
+      base08: "#ff7b72",
+      // null, undefined, function, & symbol
+      base0D: "#79c0ff",
+      // label & arrow
+      base03: text.secondary // item string expanded
+    },
+    light: {
+      base00: "transparent",
+      // bg
+      base0B: "#953800",
+      // string & date, item string
+      base09: "#116329",
+      // # & boolean
+      base07: "#0550ae",
+      // text
+      base08: "#cf222e",
+      // null, undefined, function, & symbol
+      base0D: "#0550ae",
+      // label & arrow
+      base03: text.secondary // item string expanded
+    }
+  }[mode];
+}
+const TAB_PANEL_TYPE = "Tab";
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2019-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+const log$1 = Logger$1.getLogger("src/index.ts");
+
+/** Key injected into panel configs for user-selected title (overrides setDefaultPanelTitle) */
+const PANEL_TITLE_CONFIG_KEY = "foxglovePanelTitle";
+
+// given a panel type, create a unique id for a panel
+// with the type embedded within the id
+// we need this because react-mosaic
+function getPanelIdForType(type) {
+  const factor = 1e10;
+  const rnd = Math.round(Math.random() * factor).toString(36);
+  // a panel id consists of its type, an exclamation mark for splitting, and a random val
+  // because each panel id functions is the react 'key' for the react-mosaic-component layout
+  // but also must encode the panel type for panel factory construction
+  return `${type}!${rnd}`;
+}
+function getPanelTypeFromId(id) {
+  return id.split("!")[0] ?? "";
+}
+function isTabPanel(panelId) {
+  return getPanelTypeFromId(panelId) === TAB_PANEL_TYPE;
+}
+function isTabPanelConfig(config) {
+  return config != undefined && "tabs" in config && "activeTabIdx" in config;
+}
+
+// Traverses `tree` to find the path to the specified `node`
+function getPathFromNode(node, tree,
+// eslint-disable-line no-restricted-syntax
+path = []) {
+  if (tree === node) {
+    return path;
+  }
+  if (tree != undefined && isParent(tree)) {
+    const first = getPathFromNode(node, tree.first, [...path, "first"]);
+    if (first.length > 0) {
+      return first;
+    }
+    const second = getPathFromNode(node, tree.second, [...path, "second"]);
+    if (second.length > 0) {
+      return second;
+    }
+  }
+  return [];
+}
+function mapTemplateIdsToNewIds(templateIds) {
+  const result = {};
+  for (const id of templateIds) {
+    result[id] = getPanelIdForType(getPanelTypeFromId(id));
+  }
+  return result;
+}
+function getLayoutWithNewPanelIds(layout, panelIdMap) {
+  if (typeof layout === "string") {
+    // return corresponding ID if it exists in panelIdMap
+    // (e.g. for Tab panel presets with 1 panel in active layout)
+    return panelIdMap[layout] ?? getPanelIdForType(getPanelTypeFromId(layout));
+  }
+  if (layout == undefined) {
+    return undefined;
+  }
+  const newLayout = {};
+  for (const key in layout) {
+    if (typeof layout[key] === "object" && !Array.isArray(layout[key])) {
+      newLayout[key] = getLayoutWithNewPanelIds(layout[key], panelIdMap);
+    } else if (typeof layout[key] === "string" && panelIdMap[layout[key]] != undefined) {
+      newLayout[key] = panelIdMap[layout[key]];
+    } else {
+      newLayout[key] = layout[key];
+    }
+  }
+  return newLayout;
+}
+
+// Recursively removes all empty nodes from a layout
+function compactLayout(layout) {
+  if (typeof layout === "string") {
+    return layout;
+  }
+  const prunedChildren = [layout.first, layout.second].filter(Boolean).map(compactLayout);
+  const [first, second] = prunedChildren;
+  if (first == undefined && second == undefined) {
+    return "";
+  } else if (first != undefined && second != undefined) {
+    return {
+      ...layout,
+      first,
+      second
+    };
+  }
+  return {
+    ...layout,
+    first: first ?? second ?? "",
+    second: ""
+  };
+}
+
+// Recursively replaces all leaves of the current layout
+function replaceLeafLayouts(layout, replacerFn) {
+  if (typeof layout === "string") {
+    return replacerFn(layout);
+  }
+  return {
+    ...layout,
+    first: replaceLeafLayouts(layout.first, replacerFn),
+    second: replaceLeafLayouts(layout.second, replacerFn)
+  };
+}
+
+// Replaces Tab panels with their active tab's layout
+function inlineTabPanelLayouts(layout, savedProps, preserveTabPanelIds) {
+  const tabFreeLayout = replaceLeafLayouts(layout, id => {
+    if (typeof id === "string" && isTabPanel(id) && !preserveTabPanelIds.includes(id)) {
+      const panelProps = getValidTabPanelConfig(id, savedProps);
+      const tabLayout = panelProps.tabs[panelProps.activeTabIdx]?.layout;
+      if (tabLayout != undefined) {
+        return inlineTabPanelLayouts(tabLayout, savedProps, preserveTabPanelIds);
+      }
+    }
+    return id;
+  });
+  return compactLayout(tabFreeLayout);
+}
+
+// Maps panels to their parent Tab panel
+const getParentTabPanelByPanelId = savedProps => Object.entries(savedProps).reduce((memo, [savedPanelId, savedConfig]) => {
+  if (isTabPanel(savedPanelId) && savedConfig != undefined) {
+    const tabPanelConfig = savedConfig;
+    tabPanelConfig.tabs?.forEach(tab => {
+      const panelIdsInTab = getLeaves(tab.layout ?? null);
+      panelIdsInTab.forEach(id => memo[id] = savedPanelId);
+    });
+  }
+  return memo;
+}, {});
+const replaceMaybeTabLayoutWithNewPanelIds = panelIdMap => {
+  return ({
+    id,
+    config
+  }) => {
+    return config.tabs ? {
+      id,
+      config: {
+        ...config,
+        tabs: config.tabs.map(tab => ({
+          ...tab,
+          layout: getLayoutWithNewPanelIds(tab.layout, panelIdMap)
+        }))
+      }
+    } : {
+      id,
+      config
+    };
+  };
+};
+const getSaveConfigsPayloadForAddedPanel = ({
+  id,
+  config,
+  savedProps
+}) => {
+  const templateIds = getPanelIdsInsideTabPanels([id],
+  // Merge the new config with existing configs in case the new panel is a Tab that references other existing panels
+  {
+    ...savedProps,
+    [id]: config
+  });
+  const panelIdMap = mapTemplateIdsToNewIds(templateIds);
+  const newConfigs = filterMap(templateIds, templateId => {
+    const panelId = panelIdMap[templateId];
+    const panelProps = savedProps[templateId];
+    if (panelId == undefined || panelProps == undefined) {
+      return;
+    }
+    return {
+      id: panelId,
+      config: panelProps
+    };
+  });
+  const allConfigs = [...newConfigs, {
+    id,
+    config
+  }].map(replaceMaybeTabLayoutWithNewPanelIds(panelIdMap));
+  return {
+    configs: allConfigs
+  };
+};
+function getPanelIdsInsideTabPanels(panelIds, savedProps) {
+  const tabPanelIds = panelIds.filter(isTabPanel);
+  const tabLayouts = [];
+  tabPanelIds.forEach(panelId => {
+    const tabProps = savedProps[panelId];
+    if (tabProps?.tabs) {
+      tabProps.tabs.forEach(tab => {
+        tabLayouts.push(tab.layout, ...getPanelIdsInsideTabPanels(getLeaves(tab.layout ?? null), savedProps));
+      });
+    }
+  });
+  return flatMap(tabLayouts, getLeaves);
+}
+const DEFAULT_TAB_PANEL_CONFIG = {
+  activeTabIdx: 0,
+  tabs: [{
+    title: "1",
+    layout: undefined
+  }]
+};
+// Returns all panelIds for a given layout (including layouts stored in Tab panels)
+function getAllPanelIds(layout, savedProps) {
+  const layoutPanelIds = getLeaves(layout);
+  const tabPanelIds = getPanelIdsInsideTabPanels(layoutPanelIds, savedProps);
+  return [...layoutPanelIds, ...tabPanelIds];
+}
+const validateTabPanelConfig = config => {
+  if (!config) {
+    return false;
+  }
+  if (!Array.isArray(config.tabs) || typeof config.activeTabIdx !== "number") {
+    const error = new Error("A non-Tab panel config is being operated on as if it were a Tab panel.");
+    log$1.info(`Invalid Tab panel config: ${error.message}`, config);
+    reportError(error);
+    return false;
+  }
+  if (config.activeTabIdx >= config.tabs.length) {
+    const error = new Error("A Tab panel has an activeTabIdx for a nonexistent tab.");
+    log$1.info(`Invalid Tab panel config: ${error.message}`, config);
+    reportError(error);
+    return false;
+  }
+  return true;
+};
+const updateTabPanelLayout = (layout, tabPanelConfig) => {
+  const updatedTabs = tabPanelConfig.tabs.map((tab, i) => {
+    if (i === tabPanelConfig.activeTabIdx) {
+      return {
+        ...tab,
+        layout
+      };
+    }
+    return tab;
+  });
+  // Create a new tab if there isn't one active
+  if (tabPanelConfig.activeTabIdx === -1) {
+    updatedTabs.push({
+      layout,
+      title: "1"
+    });
+  }
+  return {
+    ...tabPanelConfig,
+    tabs: updatedTabs,
+    activeTabIdx: Math.max(0, tabPanelConfig.activeTabIdx)
+  };
+};
+const removePanelFromTabPanel = (path = [], config, tabId) => {
+  if (!validateTabPanelConfig(config)) {
+    return {
+      configs: []
+    };
+  }
+  const currentTabLayout = config.tabs[config.activeTabIdx]?.layout;
+  let newTree;
+  if (path.length === 0) {
+    newTree = undefined;
+  } else {
+    const update = createRemoveUpdate(currentTabLayout ?? null, path);
+    newTree = updateTree(currentTabLayout, [update]);
+  }
+  const saveConfigsPayload = {
+    configs: [{
+      id: tabId,
+      config: updateTabPanelLayout(newTree, config)
+    }]
+  };
+  return saveConfigsPayload;
+};
+const createAddUpdates = (tree, panelId, newPath, position) => {
+  if (tree == undefined) {
+    return [];
+  }
+  const node = getNodeAtPath(tree, newPath);
+  const before = position === "left" || position === "top";
+  const [first, second] = before ? [panelId, node] : [node, panelId];
+  const direction = position === "left" || position === "right" ? "row" : "column";
+  const updates = [{
+    path: newPath,
+    spec: {
+      $set: {
+        first,
+        second,
+        direction
+      }
+    }
+  }];
+  return updates;
+};
+const addPanelToTab = (insertedPanelId, destinationPath, destinationPosition, tabConfig, tabId) => {
+  const safeTabConfig = validateTabPanelConfig(tabConfig) ? tabConfig : DEFAULT_TAB_PANEL_CONFIG;
+  const currentTabLayout = safeTabConfig.tabs[safeTabConfig.activeTabIdx]?.layout;
+  const newTree = currentTabLayout != undefined && destinationPath && destinationPosition != undefined ? updateTree(currentTabLayout, createAddUpdates(currentTabLayout, insertedPanelId, destinationPath, destinationPosition)) : insertedPanelId;
+  const saveConfigsPayload = {
+    configs: [{
+      id: tabId,
+      config: updateTabPanelLayout(newTree, safeTabConfig)
+    }]
+  };
+  return saveConfigsPayload;
+};
+function getValidTabPanelConfig(panelId, savedProps) {
+  const config = savedProps[panelId];
+  if (!config) {
+    return DEFAULT_TAB_PANEL_CONFIG;
+  }
+  return validateTabPanelConfig(config) ? config : DEFAULT_TAB_PANEL_CONFIG;
+}
+const reorderTabWithinTabPanel = ({
+  source,
+  target,
+  savedProps
+}) => {
+  const {
+    tabs,
+    activeTabIdx
+  } = getValidTabPanelConfig(source.panelId, savedProps);
+  const sourceIndex = source.tabIndex ?? tabs.length - 1; // source.tabIndex will always be set
+  const targetIndex = target.tabIndex ?? tabs.length - 1; // target.tabIndex will only be set when dropping on a tab
+
+  const nextSourceTabs = [...tabs.slice(0, sourceIndex), ...tabs.slice(sourceIndex + 1)];
+  nextSourceTabs.splice(targetIndex, 0, tabs[sourceIndex]);
+
+  // Update activeTabIdx so the active tab does not change when we move the tab
+  const movedActiveTab = activeTabIdx === source.tabIndex;
+  const movedToBeforeActiveTab = targetIndex <= activeTabIdx && sourceIndex >= activeTabIdx;
+  const movedFromBeforeActiveTab = sourceIndex <= activeTabIdx && targetIndex >= activeTabIdx;
+  let nextActiveTabIdx = activeTabIdx;
+  if (movedActiveTab) {
+    nextActiveTabIdx = targetIndex;
+  } else if (movedToBeforeActiveTab) {
+    nextActiveTabIdx++;
+  } else if (movedFromBeforeActiveTab) {
+    nextActiveTabIdx--;
+  }
+  return {
+    configs: [{
+      id: source.panelId,
+      config: {
+        tabs: nextSourceTabs,
+        activeTabIdx: nextActiveTabIdx
+      }
+    }]
+  };
+};
+const moveTabBetweenTabPanels = ({
+  source,
+  target,
+  savedProps
+}) => {
+  const sourceConfig = getValidTabPanelConfig(source.panelId, savedProps);
+  const targetConfig = getValidTabPanelConfig(target.panelId, savedProps);
+  const sourceIndex = source.tabIndex ?? sourceConfig.tabs.length;
+  const targetIndex = target.tabIndex ?? targetConfig.tabs.length;
+  const nextTabsSource = [...sourceConfig.tabs.slice(0, sourceIndex), ...sourceConfig.tabs.slice(sourceIndex + 1)];
+  const nextTabsTarget = targetConfig.tabs.slice();
+  nextTabsTarget.splice(targetIndex, 0, sourceConfig.tabs[sourceIndex]);
+
+  // Update activeTabIdx so the active tab does not change as we move the tab
+  const movedToBeforeActiveTabSource = sourceIndex <= sourceConfig.activeTabIdx;
+  const nextActiveTabIdxSource = movedToBeforeActiveTabSource ? Math.max(0, sourceConfig.activeTabIdx - 1) : sourceConfig.activeTabIdx;
+  const movedToBeforeActiveTabTarget = targetIndex <= targetConfig.activeTabIdx;
+  const nextActiveTabIdxTarget = movedToBeforeActiveTabTarget ? targetConfig.activeTabIdx + 1 : targetConfig.activeTabIdx;
+  return {
+    configs: [{
+      id: source.panelId,
+      config: {
+        tabs: nextTabsSource,
+        activeTabIdx: nextActiveTabIdxSource
+      }
+    }, {
+      id: target.panelId,
+      config: {
+        tabs: nextTabsTarget,
+        activeTabIdx: nextActiveTabIdxTarget
+      }
+    }]
+  };
+};
+const replaceAndRemovePanels = (panelArgs, layout) => {
+  const {
+    originalId,
+    newId,
+    idsToRemove = []
+  } = panelArgs;
+  const panelIds = getLeaves(layout);
+  if (xor(panelIds, idsToRemove).length === 0) {
+    return newId;
+  }
+  return uniq(compact([...idsToRemove, originalId])).reduce((currentLayout, panelIdToRemove) => {
+    if (!panelIds.includes(panelIdToRemove)) {
+      return currentLayout;
+    } else if (currentLayout === originalId) {
+      return newId;
+    } else if (currentLayout == undefined || currentLayout === panelIdToRemove) {
+      return undefined;
+    }
+    const pathToNode = getPathFromNode(panelIdToRemove, currentLayout);
+    const update = panelIdToRemove === originalId ? {
+      path: pathToNode,
+      spec: {
+        $set: newId
+      }
+    } : createRemoveUpdate(currentLayout, pathToNode);
+    return updateTree(currentLayout, [update]);
+  }, layout);
+};
+function getConfigsForNestedPanelsInsideTab(panelIdToReplace, tabPanelId, panelIdsToRemove, savedProps) {
+  const configs = [];
+  const tabPanelIds = Object.keys(savedProps).filter(isTabPanel);
+  tabPanelIds.forEach(panelId => {
+    const {
+      tabs,
+      activeTabIdx
+    } = getValidTabPanelConfig(panelId, savedProps);
+    const tabLayout = tabs[activeTabIdx]?.layout;
+    if (tabLayout != undefined && getLeaves(tabLayout).some(id => panelIdsToRemove.includes(id))) {
+      const newTabLayout = replaceAndRemovePanels({
+        originalId: panelIdToReplace,
+        newId: tabPanelId,
+        idsToRemove: panelIdsToRemove
+      }, tabLayout);
+      const newTabConfig = updateTabPanelLayout(newTabLayout, savedProps[panelId]);
+      configs.push({
+        id: panelId,
+        config: newTabConfig
+      });
+    }
+  });
+  return configs;
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2018-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+
+function toggleSelectedPanel(panelId, containingTabId, configById, selectedPanelIds) {
+  const panelIdsToDeselect = [];
+
+  // If we selected a Tab panel, deselect its children
+  const savedConfig = configById[panelId];
+  if (isTabPanel(panelId) && savedConfig) {
+    const {
+      activeTabIdx,
+      tabs
+    } = savedConfig;
+    const activeTabLayout = tabs[activeTabIdx]?.layout;
+    if (activeTabLayout != undefined) {
+      const childrenPanelIds = getAllPanelIds(activeTabLayout, configById);
+      panelIdsToDeselect.push(...childrenPanelIds);
+    }
+  }
+
+  // If we selected a child, deselect all parent Tab panels
+  const parentTabPanelByPanelId = getParentTabPanelByPanelId(configById);
+  let nextParentId = containingTabId;
+  const parentTabPanelIds = [];
+  while (nextParentId != undefined) {
+    parentTabPanelIds.push(nextParentId);
+    nextParentId = parentTabPanelByPanelId[nextParentId];
+  }
+  panelIdsToDeselect.push(...parentTabPanelIds);
+  const nextSelectedPanelIds = xor(selectedPanelIds, [panelId]);
+  const nextValidSelectedPanelIds = without(nextSelectedPanelIds, ...panelIdsToDeselect);
+  return nextValidSelectedPanelIds;
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+
+/**
+ * Encapsulates the mosaic layout, user nodes, and playback settings (everything considered to be
+ * part of a saved "layout") used by the current workspace.
+ */
+
+const log = Logger$1.getLogger("src/index.ts");
+const CurrentLayoutContext = /*#__PURE__*/createContext(undefined);
+CurrentLayoutContext.displayName = "CurrentLayoutContext";
+function usePanelMosaicId() {
+  return useGuaranteedContext(CurrentLayoutContext).mosaicId;
+}
+function useCurrentLayoutActions() {
+  return useGuaranteedContext(CurrentLayoutContext).actions;
+}
+function useCurrentLayoutSelector(selector) {
+  const currentLayout = useGuaranteedContext(CurrentLayoutContext);
+  const [, forceUpdate] = useReducer(x => x + 1, 0);
+
+  // Catch locations using unstable function selectors
+  useShouldNotChangeOften(selector, () => {
+    log.warn("useCurrentLayoutSelector is changing frequently. Rewrite your selector as a stable function.");
+  });
+  const state = useRef(undefined);
+  if (!state.current || selector !== state.current.selector) {
+    state.current = {
+      value: selectWithUnstableIdentityWarning(currentLayout.actions.getCurrentLayoutState(), selector),
+      selector
+    };
+  }
+  useLayoutEffect(() => {
+    let mounted = true;
+    const listener = layoutState => {
+      // Note: Our removeLayoutStateListener is is too late if the layout state listeners are already
+      // being invoked. Our component might become unmounted during the state listener invocation
+      if (!mounted) {
+        return;
+      }
+      const newValue = selectWithUnstableIdentityWarning(layoutState, selector);
+      if (newValue === state.current?.value) {
+        return;
+      }
+      state.current = {
+        value: newValue,
+        selector
+      };
+      forceUpdate();
+    };
+    // Update if necessary, i.e. if the state has changed between render and this effect
+    listener(currentLayout.actions.getCurrentLayoutState());
+    currentLayout.addLayoutStateListener(listener);
+    return () => {
+      mounted = false;
+      currentLayout.removeLayoutStateListener(listener);
+    };
+  }, [currentLayout, selector]);
+  return state.current.value;
+}
+function useSelectedPanels() {
+  const currentLayout = useGuaranteedContext(CurrentLayoutContext);
+  const [selectedPanelIds, setSelectedPanelIdsState] = useState(() => currentLayout.getSelectedPanelIds());
+  useLayoutEffect(() => {
+    const listener = newIds => {
+      setSelectedPanelIdsState(newIds);
+    };
+    currentLayout.addSelectedPanelIdsListener(listener);
+    return () => {
+      currentLayout.removeSelectedPanelIdsListener(listener);
+    };
+  }, [currentLayout]);
+  const setSelectedPanelIds = useGuaranteedContext(CurrentLayoutContext).setSelectedPanelIds;
+  const getSelectedPanelIds = useGuaranteedContext(CurrentLayoutContext).getSelectedPanelIds;
+  const {
+    getCurrentLayoutState: getCurrentLayout
+  } = useCurrentLayoutActions();
+  const selectAllPanels = useCallback(() => {
+    // eslint-disable-next-line no-restricted-syntax
+    const panelIds = getLeaves(getCurrentLayout().selectedLayout?.data?.layout ?? null);
+    setSelectedPanelIds(panelIds);
+  }, [getCurrentLayout, setSelectedPanelIds]);
+  const togglePanelSelected = useCallback((panelId, containingTabId) => {
+    setSelectedPanelIds(selectedIds => {
+      const {
+        selectedLayout
+      } = getCurrentLayout();
+      if (!selectedLayout?.data) {
+        return selectedIds;
+      }
+      return toggleSelectedPanel(panelId, containingTabId, selectedLayout.data.configById, selectedIds);
+    });
+  }, [setSelectedPanelIds, getCurrentLayout]);
+  return useShallowMemo({
+    getSelectedPanelIds,
+    selectedPanelIds,
+    setSelectedPanelIds,
+    selectAllPanels,
+    togglePanelSelected
+  });
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+
+// individual app configuration values are basic primitive types
+
+// Exposes an interface for reading and writing user-configurable options and other persistent application state.
+
+const AppConfigurationContext = /*#__PURE__*/createContext(undefined);
+AppConfigurationContext.displayName = "AppConfigurationContext";
+function useAppConfiguration() {
+  const storage = useContext(AppConfigurationContext);
+  if (!storage) {
+    throw new Error("An AppConfigurationContext provider is required to useAppConfiguration");
+  }
+  return storage;
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2018-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+
+function formatFrame({
+  sec,
+  nsec
+}) {
+  return `${sec}.${String.prototype.padStart.call(nsec, 9, "0")}`;
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2018-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+
+const DRIFT_THRESHOLD_SEC = 1; // Maximum amount of drift allowed.
+const WAIT_FOR_SEEK_SEC = 1; // How long we wait for a change in `lastSeekTime` before warning.
+
+Logger$1.getLogger("src/index.ts");
+
+// Logs a warning when there is a significant difference (more than `DRIFT_THRESHOLD_SEC`) between
+// a message's timestamp and `player.currentTime` OR when messages went back in time,
+// except when `player.lastSeekTime` changes, in which case panels should be clearing out their stored data.
+//
+// This is to ensure that other mechanisms that we have in place for either discarding old messages
+// or forcing an update of `player.lastSeekTime` are working properly.
+class MessageOrderTracker {
+  #lastMessages = [];
+  #lastCurrentTime;
+  #lastMessageTime;
+  #lastMessageTopic;
+  #lastLastSeekTime;
+  #warningTimeout;
+
+  /**
+   * Set this to `true` to debug out-of-order messages. It is disabled by default in production
+   * because logging messages to the console prevents them from getting garbage-collected as long as
+   * the console is not cleared.
+   */
+  #trackIncorrectMessages = false;
+  #incorrectMessages = [];
+  update(playerState) {
+    if (!playerState.activeData) {
+      return [];
+    }
+    const problems = [];
+    const {
+      messages,
+      currentTime,
+      lastSeekTime
+    } = playerState.activeData;
+    let didSeek = false;
+    if (this.#lastLastSeekTime !== lastSeekTime) {
+      this.#lastLastSeekTime = lastSeekTime;
+      if (this.#warningTimeout) {
+        clearTimeout(this.#warningTimeout);
+        this.#warningTimeout = undefined;
+        this.#incorrectMessages = [];
+      }
+      this.#warningTimeout = this.#lastMessageTime = this.#lastCurrentTime = undefined;
+      this.#lastMessages = [];
+      didSeek = true;
+    }
+    if (this.#lastMessages !== messages || this.#lastCurrentTime !== currentTime) {
+      this.#lastMessages = messages;
+      this.#lastCurrentTime = currentTime;
+      for (const message of messages) {
+        const messageTime = message.receiveTime;
+
+        // The first emit after a seek occurs from a backfill. This backfill might produce messages
+        // much older than the seek time.
+        if (!didSeek) {
+          const currentTimeDrift = Math.abs(dist.toSec(dist.subtract(messageTime, currentTime)));
+          if (currentTimeDrift > DRIFT_THRESHOLD_SEC) {
+            if (this.#trackIncorrectMessages) {
+              this.#incorrectMessages.push(message);
+            }
+            if (!this.#warningTimeout) {
+              this.#warningTimeout = setTimeout(() => {
+                // timeout has fired, we need to clear so a new timeout registers if there are more messages
+                this.#warningTimeout = undefined;
+                // reset incorrect message queue before posting warning so we never keep
+                // incorrectMessages around. The browser console will keep messages in memory when
+                // logged, so disable logging of messages unless explicitly enabled.
+                // const info = {
+                //   topic: message.topic,
+                //   currentTime,
+                //   lastSeekTime,
+                //   messageTime,
+                //   incorrectMessages: this.#trackIncorrectMessages
+                //     ? this.#incorrectMessages
+                //     : "not being tracked"
+                // };
+                this.#incorrectMessages = [];
+                // log.warn(
+                //   `Message receiveTime very different from player.currentTime; without updating lastSeekTime`,
+                //   info
+                // );
+              }, WAIT_FOR_SEEK_SEC * 1000);
+            }
+          }
+        }
+        if (this.#lastMessageTime && this.#lastMessageTopic != undefined && dist.isLessThan(messageTime, this.#lastMessageTime)) {
+          const formattedTime = formatFrame(messageTime);
+          const lastMessageTime = formatFrame(this.#lastMessageTime);
+          const errorMessage = `Processed a message on ${message.topic} at ${formattedTime} which is earlier than ` + `last processed message on ${this.#lastMessageTopic} at ${lastMessageTime}.`;
+          problems.push({
+            severity: "warn",
+            message: "Data went back in time",
+            error: new Error(errorMessage)
+          });
+        }
+        this.#lastMessageTopic = message.topic;
+        this.#lastMessageTime = messageTime;
+      }
+    }
+    return problems;
+  }
+}
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2019-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+
+const inWebWorker = () => {
+  return typeof global.postMessage !== "undefined" && typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
+};
+
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//   Copyright 2018-2021 Cruise LLC
+//
+//   This source code is licensed under the Apache License, Version 2.0,
+//   found at http://www.apache.org/licenses/LICENSE-2.0
+//   You may not use this file except in compliance with the License.
+
+const defaultNotificationHandler = (message, details, type, severity) => {
+  if (inWebWorker()) {
+    const webWorkerError = "Web Worker has uninitialized sendNotification function; this means this error message cannot show up in the UI (so we show it here in the console instead).";
+    if (process.env.NODE_ENV === "test") {
+      throw new Error(webWorkerError);
+    } else {
+      const consoleFn = severity === "error" ? console.error : severity === "warn" ? console.warn : console.info;
+      consoleFn(webWorkerError, message, details, type);
+    }
+    return;
+  } else if (process.env.NODE_ENV === "test") {
+    return;
+  }
+  console.error("Notification before error display is mounted", message, details, type);
+};
+let addNotification = defaultNotificationHandler;
+
+// Call this to add an notification to the application nav bar error component if mounted.
+// If the component is not mounted, use the console as a fallback.
+function sendNotification(message, details, type, severity) {
+  // We only want to send non-user errors and warnings to Sentry
+  if (type === "app") {
+    if (severity === "warn" || severity === "error") {
+      reportError(new AppError(details, message));
+    }
+  }
+  addNotification(message, details, type, severity);
+}
+sendNotification.expectCalledDuringTest = () => {
+  throw new Error("Should be overriden in setupTestFramework.ts");
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf ||
+      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+  return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() { this.constructor = d; }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+  __assign = Object.assign || function __assign(t) {
+      for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+      return t;
+  };
+  return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+      t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+              t[p[i]] = s[p[i]];
+      }
+  return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+  return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+      var context = {};
+      for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+      for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+      context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+      var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+      if (kind === "accessor") {
+          if (result === void 0) continue;
+          if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+          if (_ = accept(result.get)) descriptor.get = _;
+          if (_ = accept(result.set)) descriptor.set = _;
+          if (_ = accept(result.init)) initializers.unshift(_);
+      }
+      else if (_ = accept(result)) {
+          if (kind === "field") initializers.unshift(_);
+          else descriptor[key] = _;
+      }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+}
+function __runInitializers(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  }
+  return useValue ? value : void 0;
+}
+function __propKey(x) {
+  return typeof x === "symbol" ? x : "".concat(x);
+}
+function __setFunctionName(f, name, prefix) {
+  if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+  return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+}
+function __metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+  return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+      function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+  function verb(n) { return function (v) { return step([n, v]); }; }
+  function step(op) {
+      if (f) throw new TypeError("Generator is already executing.");
+      while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+              case 0: case 1: t = op; break;
+              case 4: _.label++; return { value: op[1], done: false };
+              case 5: _.label++; y = op[1]; op = [0]; continue;
+              case 7: op = _.ops.pop(); _.trys.pop(); continue;
+              default:
+                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                  if (t[2]) _.ops.pop();
+                  _.trys.pop(); continue;
+          }
+          op = body.call(thisArg, _);
+      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+
+var __createBinding = Object.create ? (function(o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  var desc = Object.getOwnPropertyDescriptor(m, k);
+  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+  }
+  Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+
+function __exportStar(m, o) {
+  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
+}
+
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+      next: function () {
+          if (o && i >= o.length) o = void 0;
+          return { value: o && o[i++], done: !o };
+      }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  }
+  catch (error) { e = { error: error }; }
+  finally {
+      try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+      }
+      finally { if (e) throw e.error; }
+  }
+  return ar;
+}
+
+/** @deprecated */
+function __spread() {
+  for (var ar = [], i = 0; i < arguments.length; i++)
+      ar = ar.concat(__read(arguments[i]));
+  return ar;
+}
+
+/** @deprecated */
+function __spreadArrays() {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+  for (var r = Array(s), k = 0, i = 0; i < il; i++)
+      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+          r[k] = a[j];
+  return r;
+}
+
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+      if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+      }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+  function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+  function fulfill(value) { resume("next", value); }
+  function reject(value) { resume("throw", value); }
+  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+}
+
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+function __makeTemplateObject(cooked, raw) {
+  if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+  return cooked;
+}
+var __setModuleDefault = Object.create ? (function(o, v) {
+  Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+  o["default"] = v;
+};
+
+function __importStar(mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+  __setModuleDefault(result, mod);
+  return result;
+}
+
+function __importDefault(mod) {
+  return (mod && mod.__esModule) ? mod : { default: mod };
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+function __classPrivateFieldIn(state, receiver) {
+  if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
+  return typeof state === "function" ? receiver === state : state.has(receiver);
+}
+
+function __addDisposableResource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose;
+    if (async) {
+        if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+        dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+        if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+        dispose = value[Symbol.dispose];
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    env.stack.push({ value: value, dispose: dispose, async: async });
+  }
+  else if (async) {
+    env.stack.push({ async: true });
+  }
+  return value;
+}
+
+var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function __disposeResources(env) {
+  function fail(e) {
+    env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+    env.hasError = true;
+  }
+  function next() {
+    while (env.stack.length) {
+      var rec = env.stack.pop();
+      try {
+        var result = rec.dispose && rec.dispose.call(rec.value);
+        if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+      }
+      catch (e) {
+          fail(e);
+      }
+    }
+    if (env.hasError) throw env.error;
+  }
+  return next();
+}
+
+var tslib_es6 = {
+  __extends,
+  __assign,
+  __rest,
+  __decorate,
+  __param,
+  __metadata,
+  __awaiter,
+  __generator,
+  __createBinding,
+  __exportStar,
+  __values,
+  __read,
+  __spread,
+  __spreadArrays,
+  __spreadArray,
+  __await,
+  __asyncGenerator,
+  __asyncDelegator,
+  __asyncValues,
+  __makeTemplateObject,
+  __importStar,
+  __importDefault,
+  __classPrivateFieldGet,
+  __classPrivateFieldSet,
+  __classPrivateFieldIn,
+  __addDisposableResource,
+  __disposeResources,
+};
+
+var tslib_es6$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    __addDisposableResource: __addDisposableResource,
+    get __assign () { return __assign; },
+    __asyncDelegator: __asyncDelegator,
+    __asyncGenerator: __asyncGenerator,
+    __asyncValues: __asyncValues,
+    __await: __await,
+    __awaiter: __awaiter,
+    __classPrivateFieldGet: __classPrivateFieldGet,
+    __classPrivateFieldIn: __classPrivateFieldIn,
+    __classPrivateFieldSet: __classPrivateFieldSet,
+    __createBinding: __createBinding,
+    __decorate: __decorate,
+    __disposeResources: __disposeResources,
+    __esDecorate: __esDecorate,
+    __exportStar: __exportStar,
+    __extends: __extends,
+    __generator: __generator,
+    __importDefault: __importDefault,
+    __importStar: __importStar,
+    __makeTemplateObject: __makeTemplateObject,
+    __metadata: __metadata,
+    __param: __param,
+    __propKey: __propKey,
+    __read: __read,
+    __rest: __rest,
+    __runInitializers: __runInitializers,
+    __setFunctionName: __setFunctionName,
+    __spread: __spread,
+    __spreadArray: __spreadArray,
+    __spreadArrays: __spreadArrays,
+    __values: __values,
+    default: tslib_es6
+});
+
+export { arrayPush as $, AppError as A, inlineTabPanelLayouts as B, getAllPanelIds as C, getConfigsForNestedPanelsInsideTab as D, reorderTabWithinTabPanel as E, moveTabBetweenTabPanels as F, isTabPanelConfig as G, DEFAULT_TAB_PANEL_CONFIG as H, addPanelToTab as I, createAddUpdates as J, filterMap as K, Logger$1 as L, uniq as M, useShallowMemo as N, CurrentLayoutContext as O, MessageOrderTracker as P, AppConfigurationContext as Q, __rest as R, __spreadArray as S, TAB_PANEL_TYPE as T, uint8ArrayToUint16Array as U, isSymbol as V, toString as W, keys as X, getSymbols as Y, stubArray as Z, __assign as _, baseEach as a, baseGetAllKeys as a0, getAllKeys as a1, arrayMap as a2, baseUniq as a3, useMustNotChange as a4, useCurrentLayoutActions as a5, useCurrentLayoutSelector as a6, usePanelMosaicId as a7, useSelectedPanels as a8, PANEL_TITLE_CONFIG_KEY as a9, noop as aa, useAppConfiguration as ab, useValueChangedDebugLog as ac, useJsonTreeTheme as ad, tslib_es6$1 as ae, baseFlatten as b, baseIteratee as c, dist as d, estimateObjectSize as e, baseDifference as f, getTag as g, baseKeys as h, i420ToRgbaToPointcloudWorker as i, baseIsEqual as j, castPath as k, baseGet as l, hasIn as m, shallowequal$1 as n, getPanelIdsInsideTabPanels as o, getPanelTypeFromId as p, removePanelFromTabPanel as q, reportError as r, sendNotification as s, toKey as t, useGuaranteedContext as u, getPanelIdForType as v, getPathFromNode as w, updateTabPanelLayout as x, getSaveConfigsPayloadForAddedPanel as y, replaceAndRemovePanels as z };