cs

adi-ui/.pnpm-store/v10/files/00/041f29e977545e325337a4be578ec84903aebe02b066f0e1a2fdf07f6efc909015164a93b3ad15323fad9662f054186e878fc47f354279455535dbf0c92f74

@@ -0,0 +1,67 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @typedef {import("./Module")} Module */
+
+class ModuleParseError extends WebpackError {
+	/**
+	 * @param {Module} module the errored module
+	 * @param {string} source source code
+	 * @param {Error&any} err the parse error
+	 * @param {string[]} loaders the loaders used
+	 */
+	constructor(module, source, err, loaders) {
+		let message = "Module parse failed: " + err.message;
+		let loc = undefined;
+		if (loaders.length >= 1) {
+			message += `\nFile was processed with these loaders:${loaders
+				.map(loader => `\n * ${loader}`)
+				.join("")}`;
+			message +=
+				"\nYou may need an additional loader to handle the result of these loaders.";
+		} else {
+			message +=
+				"\nYou may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders";
+		}
+		if (
+			err.loc &&
+			typeof err.loc === "object" &&
+			typeof err.loc.line === "number"
+		) {
+			var lineNumber = err.loc.line;
+			if (/[\0\u0001\u0002\u0003\u0004\u0005\u0006\u0007]/.test(source)) {
+				// binary file
+				message += "\n(Source code omitted for this binary file)";
+			} else {
+				const sourceLines = source.split(/\r?\n/);
+				const start = Math.max(0, lineNumber - 3);
+				const linesBefore = sourceLines.slice(start, lineNumber - 1);
+				const theLine = sourceLines[lineNumber - 1];
+				const linesAfter = sourceLines.slice(lineNumber, lineNumber + 2);
+				message +=
+					linesBefore.map(l => `\n| ${l}`).join("") +
+					`\n> ${theLine}` +
+					linesAfter.map(l => `\n| ${l}`).join("");
+			}
+			loc = err.loc;
+		} else {
+			message += "\n" + err.stack;
+		}
+
+		super(message);
+
+		this.name = "ModuleParseError";
+		this.module = module;
+		this.loc = loc;
+		this.error = err;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+}
+
+module.exports = ModuleParseError;

adi-ui/.pnpm-store/v10/files/00/0453ee04cfec4f7e5cba7dc66afbc31b870edd24403d1e1fcb694e8c3c7cd5019b0ba04e57c4c4f0d358886d8cfba709e05619f45cbb6d1f89031a3acbc4a8

@@ -0,0 +1,29 @@
+import {  concat as concatStatic } from '../observable/concat';
+import { Observable } from '../Observable';
+import { ObservableInput, OperatorFunction, MonoTypeOperatorFunction, SchedulerLike } from '../types';
+
+/* tslint:disable:max-line-length */
+/** @deprecated Deprecated in favor of static concat. */
+export function concat<T>(scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+/** @deprecated Deprecated in favor of static concat. */
+export function concat<T, T2>(v2: ObservableInput<T2>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2>;
+/** @deprecated Deprecated in favor of static concat. */
+export function concat<T, T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3>;
+/** @deprecated Deprecated in favor of static concat. */
+export function concat<T, T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4>;
+/** @deprecated Deprecated in favor of static concat. */
+export function concat<T, T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4 | T5>;
+/** @deprecated Deprecated in favor of static concat. */
+export function concat<T, T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: SchedulerLike): OperatorFunction<T, T | T2 | T3 | T4 | T5 | T6>;
+/** @deprecated Deprecated in favor of static concat. */
+export function concat<T>(...observables: Array<ObservableInput<T> | SchedulerLike>): MonoTypeOperatorFunction<T>;
+/** @deprecated Deprecated in favor of static concat. */
+export function concat<T, R>(...observables: Array<ObservableInput<any> | SchedulerLike>): OperatorFunction<T, R>;
+/* tslint:enable:max-line-length */
+
+/**
+ * @deprecated Deprecated in favor of static {@link concat}.
+ */
+export function concat<T, R>(...observables: Array<ObservableInput<any> | SchedulerLike>): OperatorFunction<T, R> {
+  return (source: Observable<T>) => source.lift.call(concatStatic(source, ...observables));
+}

adi-ui/.pnpm-store/v10/files/00/06c71797acdece36f6efb7aea69bdeac909f04f78ba6c17c432f369b4309add1b422f945cd15f55c2df1a0112064e0c84419c25996010da0ce3931f932a9a7

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../../actual/instance/repeat');
+
+module.exports = parent;

adi-ui/.pnpm-store/v10/files/00/07213771ccbfdf3b2027e0275cced7836fa7fbbb10d49acf73eb1bb0f8c74c9561c19a3cd491eb5cf92f59502ee0fa977c6c619409dd83d0e7ea3b1ac53e29

@@ -0,0 +1,1525 @@
+exports = module.exports = SemVer
+
+var debug
+/* istanbul ignore next */
+if (typeof process === 'object' &&
+    process.env &&
+    process.env.NODE_DEBUG &&
+    /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
+  debug = function () {
+    var args = Array.prototype.slice.call(arguments, 0)
+    args.unshift('SEMVER')
+    console.log.apply(console, args)
+  }
+} else {
+  debug = function () {}
+}
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+exports.SEMVER_SPEC_VERSION = '2.0.0'
+
+var MAX_LENGTH = 256
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
+  /* istanbul ignore next */ 9007199254740991
+
+// Max safe segment length for coercion.
+var MAX_SAFE_COMPONENT_LENGTH = 16
+
+var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6
+
+// The actual regexps go on exports.re
+var re = exports.re = []
+var safeRe = exports.safeRe = []
+var src = exports.src = []
+var R = 0
+
+var LETTERDASHNUMBER = '[a-zA-Z0-9-]'
+
+// Replace some greedy regex tokens to prevent regex dos issues. These regex are
+// used internally via the safeRe object since all inputs in this library get
+// normalized first to trim and collapse all extra whitespace. The original
+// regexes are exported for userland consumption and lower level usage. A
+// future breaking change could export the safer regex only with a note that
+// all input should have extra whitespace removed.
+var safeRegexReplacements = [
+  ['\\s', 1],
+  ['\\d', MAX_LENGTH],
+  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
+]
+
+function makeSafeRe (value) {
+  for (var i = 0; i < safeRegexReplacements.length; i++) {
+    var token = safeRegexReplacements[i][0]
+    var max = safeRegexReplacements[i][1]
+    value = value
+      .split(token + '*').join(token + '{0,' + max + '}')
+      .split(token + '+').join(token + '{1,' + max + '}')
+  }
+  return value
+}
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+var NUMERICIDENTIFIER = R++
+src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'
+var NUMERICIDENTIFIERLOOSE = R++
+src[NUMERICIDENTIFIERLOOSE] = '\\d+'
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+var NONNUMERICIDENTIFIER = R++
+src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-]' + LETTERDASHNUMBER + '*'
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+var MAINVERSION = R++
+src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+                   '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+                   '(' + src[NUMERICIDENTIFIER] + ')'
+
+var MAINVERSIONLOOSE = R++
+src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')'
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+var PRERELEASEIDENTIFIER = R++
+src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
+                            '|' + src[NONNUMERICIDENTIFIER] + ')'
+
+var PRERELEASEIDENTIFIERLOOSE = R++
+src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
+                                 '|' + src[NONNUMERICIDENTIFIER] + ')'
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+var PRERELEASE = R++
+src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
+                  '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'
+
+var PRERELEASELOOSE = R++
+src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
+                       '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+var BUILDIDENTIFIER = R++
+src[BUILDIDENTIFIER] = LETTERDASHNUMBER + '+'
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+var BUILD = R++
+src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
+             '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups.  The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+var FULL = R++
+var FULLPLAIN = 'v?' + src[MAINVERSION] +
+                src[PRERELEASE] + '?' +
+                src[BUILD] + '?'
+
+src[FULL] = '^' + FULLPLAIN + '$'
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
+                 src[PRERELEASELOOSE] + '?' +
+                 src[BUILD] + '?'
+
+var LOOSE = R++
+src[LOOSE] = '^' + LOOSEPLAIN + '$'
+
+var GTLT = R++
+src[GTLT] = '((?:<|>)?=?)'
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+var XRANGEIDENTIFIERLOOSE = R++
+src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
+var XRANGEIDENTIFIER = R++
+src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'
+
+var XRANGEPLAIN = R++
+src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
+                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+                   '(?:' + src[PRERELEASE] + ')?' +
+                   src[BUILD] + '?' +
+                   ')?)?'
+
+var XRANGEPLAINLOOSE = R++
+src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:' + src[PRERELEASELOOSE] + ')?' +
+                        src[BUILD] + '?' +
+                        ')?)?'
+
+var XRANGE = R++
+src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'
+var XRANGELOOSE = R++
+src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+var COERCE = R++
+src[COERCE] = '(?:^|[^\\d])' +
+              '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
+              '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+              '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+              '(?:$|[^\\d])'
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+var LONETILDE = R++
+src[LONETILDE] = '(?:~>?)'
+
+var TILDETRIM = R++
+src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'
+re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g')
+safeRe[TILDETRIM] = new RegExp(makeSafeRe(src[TILDETRIM]), 'g')
+var tildeTrimReplace = '$1~'
+
+var TILDE = R++
+src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'
+var TILDELOOSE = R++
+src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+var LONECARET = R++
+src[LONECARET] = '(?:\\^)'
+
+var CARETTRIM = R++
+src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'
+re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g')
+safeRe[CARETTRIM] = new RegExp(makeSafeRe(src[CARETTRIM]), 'g')
+var caretTrimReplace = '$1^'
+
+var CARET = R++
+src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'
+var CARETLOOSE = R++
+src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+var COMPARATORLOOSE = R++
+src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'
+var COMPARATOR = R++
+src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+var COMPARATORTRIM = R++
+src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
+                      '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'
+
+// this one has to use the /g flag
+re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g')
+safeRe[COMPARATORTRIM] = new RegExp(makeSafeRe(src[COMPARATORTRIM]), 'g')
+var comparatorTrimReplace = '$1$2$3'
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+var HYPHENRANGE = R++
+src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
+                   '\\s+-\\s+' +
+                   '(' + src[XRANGEPLAIN] + ')' +
+                   '\\s*$'
+
+var HYPHENRANGELOOSE = R++
+src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
+                        '\\s+-\\s+' +
+                        '(' + src[XRANGEPLAINLOOSE] + ')' +
+                        '\\s*$'
+
+// Star ranges basically just allow anything at all.
+var STAR = R++
+src[STAR] = '(<|>)?=?\\s*\\*'
+
+// Compile to actual regexp objects.
+// All are flag-free, unless they were created above with a flag.
+for (var i = 0; i < R; i++) {
+  debug(i, src[i])
+  if (!re[i]) {
+    re[i] = new RegExp(src[i])
+
+    // Replace all greedy whitespace to prevent regex dos issues. These regex are
+    // used internally via the safeRe object since all inputs in this library get
+    // normalized first to trim and collapse all extra whitespace. The original
+    // regexes are exported for userland consumption and lower level usage. A
+    // future breaking change could export the safer regex only with a note that
+    // all input should have extra whitespace removed.
+    safeRe[i] = new RegExp(makeSafeRe(src[i]))
+  }
+}
+
+exports.parse = parse
+function parse (version, options) {
+  if (!options || typeof options !== 'object') {
+    options = {
+      loose: !!options,
+      includePrerelease: false
+    }
+  }
+
+  if (version instanceof SemVer) {
+    return version
+  }
+
+  if (typeof version !== 'string') {
+    return null
+  }
+
+  if (version.length > MAX_LENGTH) {
+    return null
+  }
+
+  var r = options.loose ? safeRe[LOOSE] : safeRe[FULL]
+  if (!r.test(version)) {
+    return null
+  }
+
+  try {
+    return new SemVer(version, options)
+  } catch (er) {
+    return null
+  }
+}
+
+exports.valid = valid
+function valid (version, options) {
+  var v = parse(version, options)
+  return v ? v.version : null
+}
+
+exports.clean = clean
+function clean (version, options) {
+  var s = parse(version.trim().replace(/^[=v]+/, ''), options)
+  return s ? s.version : null
+}
+
+exports.SemVer = SemVer
+
+function SemVer (version, options) {
+  if (!options || typeof options !== 'object') {
+    options = {
+      loose: !!options,
+      includePrerelease: false
+    }
+  }
+  if (version instanceof SemVer) {
+    if (version.loose === options.loose) {
+      return version
+    } else {
+      version = version.version
+    }
+  } else if (typeof version !== 'string') {
+    throw new TypeError('Invalid Version: ' + version)
+  }
+
+  if (version.length > MAX_LENGTH) {
+    throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
+  }
+
+  if (!(this instanceof SemVer)) {
+    return new SemVer(version, options)
+  }
+
+  debug('SemVer', version, options)
+  this.options = options
+  this.loose = !!options.loose
+
+  var m = version.trim().match(options.loose ? safeRe[LOOSE] : safeRe[FULL])
+
+  if (!m) {
+    throw new TypeError('Invalid Version: ' + version)
+  }
+
+  this.raw = version
+
+  // these are actually numbers
+  this.major = +m[1]
+  this.minor = +m[2]
+  this.patch = +m[3]
+
+  if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+    throw new TypeError('Invalid major version')
+  }
+
+  if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+    throw new TypeError('Invalid minor version')
+  }
+
+  if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+    throw new TypeError('Invalid patch version')
+  }
+
+  // numberify any prerelease numeric ids
+  if (!m[4]) {
+    this.prerelease = []
+  } else {
+    this.prerelease = m[4].split('.').map(function (id) {
+      if (/^[0-9]+$/.test(id)) {
+        var num = +id
+        if (num >= 0 && num < MAX_SAFE_INTEGER) {
+          return num
+        }
+      }
+      return id
+    })
+  }
+
+  this.build = m[5] ? m[5].split('.') : []
+  this.format()
+}
+
+SemVer.prototype.format = function () {
+  this.version = this.major + '.' + this.minor + '.' + this.patch
+  if (this.prerelease.length) {
+    this.version += '-' + this.prerelease.join('.')
+  }
+  return this.version
+}
+
+SemVer.prototype.toString = function () {
+  return this.version
+}
+
+SemVer.prototype.compare = function (other) {
+  debug('SemVer.compare', this.version, this.options, other)
+  if (!(other instanceof SemVer)) {
+    other = new SemVer(other, this.options)
+  }
+
+  return this.compareMain(other) || this.comparePre(other)
+}
+
+SemVer.prototype.compareMain = function (other) {
+  if (!(other instanceof SemVer)) {
+    other = new SemVer(other, this.options)
+  }
+
+  return compareIdentifiers(this.major, other.major) ||
+         compareIdentifiers(this.minor, other.minor) ||
+         compareIdentifiers(this.patch, other.patch)
+}
+
+SemVer.prototype.comparePre = function (other) {
+  if (!(other instanceof SemVer)) {
+    other = new SemVer(other, this.options)
+  }
+
+  // NOT having a prerelease is > having one
+  if (this.prerelease.length && !other.prerelease.length) {
+    return -1
+  } else if (!this.prerelease.length && other.prerelease.length) {
+    return 1
+  } else if (!this.prerelease.length && !other.prerelease.length) {
+    return 0
+  }
+
+  var i = 0
+  do {
+    var a = this.prerelease[i]
+    var b = other.prerelease[i]
+    debug('prerelease compare', i, a, b)
+    if (a === undefined && b === undefined) {
+      return 0
+    } else if (b === undefined) {
+      return 1
+    } else if (a === undefined) {
+      return -1
+    } else if (a === b) {
+      continue
+    } else {
+      return compareIdentifiers(a, b)
+    }
+  } while (++i)
+}
+
+// preminor will bump the version up to the next minor release, and immediately
+// down to pre-release. premajor and prepatch work the same way.
+SemVer.prototype.inc = function (release, identifier) {
+  switch (release) {
+    case 'premajor':
+      this.prerelease.length = 0
+      this.patch = 0
+      this.minor = 0
+      this.major++
+      this.inc('pre', identifier)
+      break
+    case 'preminor':
+      this.prerelease.length = 0
+      this.patch = 0
+      this.minor++
+      this.inc('pre', identifier)
+      break
+    case 'prepatch':
+      // If this is already a prerelease, it will bump to the next version
+      // drop any prereleases that might already exist, since they are not
+      // relevant at this point.
+      this.prerelease.length = 0
+      this.inc('patch', identifier)
+      this.inc('pre', identifier)
+      break
+    // If the input is a non-prerelease version, this acts the same as
+    // prepatch.
+    case 'prerelease':
+      if (this.prerelease.length === 0) {
+        this.inc('patch', identifier)
+      }
+      this.inc('pre', identifier)
+      break
+
+    case 'major':
+      // If this is a pre-major version, bump up to the same major version.
+      // Otherwise increment major.
+      // 1.0.0-5 bumps to 1.0.0
+      // 1.1.0 bumps to 2.0.0
+      if (this.minor !== 0 ||
+          this.patch !== 0 ||
+          this.prerelease.length === 0) {
+        this.major++
+      }
+      this.minor = 0
+      this.patch = 0
+      this.prerelease = []
+      break
+    case 'minor':
+      // If this is a pre-minor version, bump up to the same minor version.
+      // Otherwise increment minor.
+      // 1.2.0-5 bumps to 1.2.0
+      // 1.2.1 bumps to 1.3.0
+      if (this.patch !== 0 || this.prerelease.length === 0) {
+        this.minor++
+      }
+      this.patch = 0
+      this.prerelease = []
+      break
+    case 'patch':
+      // If this is not a pre-release version, it will increment the patch.
+      // If it is a pre-release it will bump up to the same patch version.
+      // 1.2.0-5 patches to 1.2.0
+      // 1.2.0 patches to 1.2.1
+      if (this.prerelease.length === 0) {
+        this.patch++
+      }
+      this.prerelease = []
+      break
+    // This probably shouldn't be used publicly.
+    // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
+    case 'pre':
+      if (this.prerelease.length === 0) {
+        this.prerelease = [0]
+      } else {
+        var i = this.prerelease.length
+        while (--i >= 0) {
+          if (typeof this.prerelease[i] === 'number') {
+            this.prerelease[i]++
+            i = -2
+          }
+        }
+        if (i === -1) {
+          // didn't increment anything
+          this.prerelease.push(0)
+        }
+      }
+      if (identifier) {
+        // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+        // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+        if (this.prerelease[0] === identifier) {
+          if (isNaN(this.prerelease[1])) {
+            this.prerelease = [identifier, 0]
+          }
+        } else {
+          this.prerelease = [identifier, 0]
+        }
+      }
+      break
+
+    default:
+      throw new Error('invalid increment argument: ' + release)
+  }
+  this.format()
+  this.raw = this.version
+  return this
+}
+
+exports.inc = inc
+function inc (version, release, loose, identifier) {
+  if (typeof (loose) === 'string') {
+    identifier = loose
+    loose = undefined
+  }
+
+  try {
+    return new SemVer(version, loose).inc(release, identifier).version
+  } catch (er) {
+    return null
+  }
+}
+
+exports.diff = diff
+function diff (version1, version2) {
+  if (eq(version1, version2)) {
+    return null
+  } else {
+    var v1 = parse(version1)
+    var v2 = parse(version2)
+    var prefix = ''
+    if (v1.prerelease.length || v2.prerelease.length) {
+      prefix = 'pre'
+      var defaultResult = 'prerelease'
+    }
+    for (var key in v1) {
+      if (key === 'major' || key === 'minor' || key === 'patch') {
+        if (v1[key] !== v2[key]) {
+          return prefix + key
+        }
+      }
+    }
+    return defaultResult // may be undefined
+  }
+}
+
+exports.compareIdentifiers = compareIdentifiers
+
+var numeric = /^[0-9]+$/
+function compareIdentifiers (a, b) {
+  var anum = numeric.test(a)
+  var bnum = numeric.test(b)
+
+  if (anum && bnum) {
+    a = +a
+    b = +b
+  }
+
+  return a === b ? 0
+    : (anum && !bnum) ? -1
+    : (bnum && !anum) ? 1
+    : a < b ? -1
+    : 1
+}
+
+exports.rcompareIdentifiers = rcompareIdentifiers
+function rcompareIdentifiers (a, b) {
+  return compareIdentifiers(b, a)
+}
+
+exports.major = major
+function major (a, loose) {
+  return new SemVer(a, loose).major
+}
+
+exports.minor = minor
+function minor (a, loose) {
+  return new SemVer(a, loose).minor
+}
+
+exports.patch = patch
+function patch (a, loose) {
+  return new SemVer(a, loose).patch
+}
+
+exports.compare = compare
+function compare (a, b, loose) {
+  return new SemVer(a, loose).compare(new SemVer(b, loose))
+}
+
+exports.compareLoose = compareLoose
+function compareLoose (a, b) {
+  return compare(a, b, true)
+}
+
+exports.rcompare = rcompare
+function rcompare (a, b, loose) {
+  return compare(b, a, loose)
+}
+
+exports.sort = sort
+function sort (list, loose) {
+  return list.sort(function (a, b) {
+    return exports.compare(a, b, loose)
+  })
+}
+
+exports.rsort = rsort
+function rsort (list, loose) {
+  return list.sort(function (a, b) {
+    return exports.rcompare(a, b, loose)
+  })
+}
+
+exports.gt = gt
+function gt (a, b, loose) {
+  return compare(a, b, loose) > 0
+}
+
+exports.lt = lt
+function lt (a, b, loose) {
+  return compare(a, b, loose) < 0
+}
+
+exports.eq = eq
+function eq (a, b, loose) {
+  return compare(a, b, loose) === 0
+}
+
+exports.neq = neq
+function neq (a, b, loose) {
+  return compare(a, b, loose) !== 0
+}
+
+exports.gte = gte
+function gte (a, b, loose) {
+  return compare(a, b, loose) >= 0
+}
+
+exports.lte = lte
+function lte (a, b, loose) {
+  return compare(a, b, loose) <= 0
+}
+
+exports.cmp = cmp
+function cmp (a, op, b, loose) {
+  switch (op) {
+    case '===':
+      if (typeof a === 'object')
+        a = a.version
+      if (typeof b === 'object')
+        b = b.version
+      return a === b
+
+    case '!==':
+      if (typeof a === 'object')
+        a = a.version
+      if (typeof b === 'object')
+        b = b.version
+      return a !== b
+
+    case '':
+    case '=':
+    case '==':
+      return eq(a, b, loose)
+
+    case '!=':
+      return neq(a, b, loose)
+
+    case '>':
+      return gt(a, b, loose)
+
+    case '>=':
+      return gte(a, b, loose)
+
+    case '<':
+      return lt(a, b, loose)
+
+    case '<=':
+      return lte(a, b, loose)
+
+    default:
+      throw new TypeError('Invalid operator: ' + op)
+  }
+}
+
+exports.Comparator = Comparator
+function Comparator (comp, options) {
+  if (!options || typeof options !== 'object') {
+    options = {
+      loose: !!options,
+      includePrerelease: false
+    }
+  }
+
+  if (comp instanceof Comparator) {
+    if (comp.loose === !!options.loose) {
+      return comp
+    } else {
+      comp = comp.value
+    }
+  }
+
+  if (!(this instanceof Comparator)) {
+    return new Comparator(comp, options)
+  }
+
+  comp = comp.trim().split(/\s+/).join(' ')
+  debug('comparator', comp, options)
+  this.options = options
+  this.loose = !!options.loose
+  this.parse(comp)
+
+  if (this.semver === ANY) {
+    this.value = ''
+  } else {
+    this.value = this.operator + this.semver.version
+  }
+
+  debug('comp', this)
+}
+
+var ANY = {}
+Comparator.prototype.parse = function (comp) {
+  var r = this.options.loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR]
+  var m = comp.match(r)
+
+  if (!m) {
+    throw new TypeError('Invalid comparator: ' + comp)
+  }
+
+  this.operator = m[1]
+  if (this.operator === '=') {
+    this.operator = ''
+  }
+
+  // if it literally is just '>' or '' then allow anything.
+  if (!m[2]) {
+    this.semver = ANY
+  } else {
+    this.semver = new SemVer(m[2], this.options.loose)
+  }
+}
+
+Comparator.prototype.toString = function () {
+  return this.value
+}
+
+Comparator.prototype.test = function (version) {
+  debug('Comparator.test', version, this.options.loose)
+
+  if (this.semver === ANY) {
+    return true
+  }
+
+  if (typeof version === 'string') {
+    version = new SemVer(version, this.options)
+  }
+
+  return cmp(version, this.operator, this.semver, this.options)
+}
+
+Comparator.prototype.intersects = function (comp, options) {
+  if (!(comp instanceof Comparator)) {
+    throw new TypeError('a Comparator is required')
+  }
+
+  if (!options || typeof options !== 'object') {
+    options = {
+      loose: !!options,
+      includePrerelease: false
+    }
+  }
+
+  var rangeTmp
+
+  if (this.operator === '') {
+    rangeTmp = new Range(comp.value, options)
+    return satisfies(this.value, rangeTmp, options)
+  } else if (comp.operator === '') {
+    rangeTmp = new Range(this.value, options)
+    return satisfies(comp.semver, rangeTmp, options)
+  }
+
+  var sameDirectionIncreasing =
+    (this.operator === '>=' || this.operator === '>') &&
+    (comp.operator === '>=' || comp.operator === '>')
+  var sameDirectionDecreasing =
+    (this.operator === '<=' || this.operator === '<') &&
+    (comp.operator === '<=' || comp.operator === '<')
+  var sameSemVer = this.semver.version === comp.semver.version
+  var differentDirectionsInclusive =
+    (this.operator === '>=' || this.operator === '<=') &&
+    (comp.operator === '>=' || comp.operator === '<=')
+  var oppositeDirectionsLessThan =
+    cmp(this.semver, '<', comp.semver, options) &&
+    ((this.operator === '>=' || this.operator === '>') &&
+    (comp.operator === '<=' || comp.operator === '<'))
+  var oppositeDirectionsGreaterThan =
+    cmp(this.semver, '>', comp.semver, options) &&
+    ((this.operator === '<=' || this.operator === '<') &&
+    (comp.operator === '>=' || comp.operator === '>'))
+
+  return sameDirectionIncreasing || sameDirectionDecreasing ||
+    (sameSemVer && differentDirectionsInclusive) ||
+    oppositeDirectionsLessThan || oppositeDirectionsGreaterThan
+}
+
+exports.Range = Range
+function Range (range, options) {
+  if (!options || typeof options !== 'object') {
+    options = {
+      loose: !!options,
+      includePrerelease: false
+    }
+  }
+
+  if (range instanceof Range) {
+    if (range.loose === !!options.loose &&
+        range.includePrerelease === !!options.includePrerelease) {
+      return range
+    } else {
+      return new Range(range.raw, options)
+    }
+  }
+
+  if (range instanceof Comparator) {
+    return new Range(range.value, options)
+  }
+
+  if (!(this instanceof Range)) {
+    return new Range(range, options)
+  }
+
+  this.options = options
+  this.loose = !!options.loose
+  this.includePrerelease = !!options.includePrerelease
+
+  // First reduce all whitespace as much as possible so we do not have to rely
+  // on potentially slow regexes like \s*. This is then stored and used for
+  // future error messages as well.
+  this.raw = range
+    .trim()
+    .split(/\s+/)
+    .join(' ')
+
+  // First, split based on boolean or ||
+  this.set = this.raw.split('||').map(function (range) {
+    return this.parseRange(range.trim())
+  }, this).filter(function (c) {
+    // throw out any that are not relevant for whatever reason
+    return c.length
+  })
+
+  if (!this.set.length) {
+    throw new TypeError('Invalid SemVer Range: ' + this.raw)
+  }
+
+  this.format()
+}
+
+Range.prototype.format = function () {
+  this.range = this.set.map(function (comps) {
+    return comps.join(' ').trim()
+  }).join('||').trim()
+  return this.range
+}
+
+Range.prototype.toString = function () {
+  return this.range
+}
+
+Range.prototype.parseRange = function (range) {
+  var loose = this.options.loose
+  // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+  var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE]
+  range = range.replace(hr, hyphenReplace)
+  debug('hyphen replace', range)
+  // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+  range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace)
+  debug('comparator trim', range, safeRe[COMPARATORTRIM])
+
+  // `~ 1.2.3` => `~1.2.3`
+  range = range.replace(safeRe[TILDETRIM], tildeTrimReplace)
+
+  // `^ 1.2.3` => `^1.2.3`
+  range = range.replace(safeRe[CARETTRIM], caretTrimReplace)
+
+  // At this point, the range is completely trimmed and
+  // ready to be split into comparators.
+  var compRe = loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR]
+  var set = range.split(' ').map(function (comp) {
+    return parseComparator(comp, this.options)
+  }, this).join(' ').split(/\s+/)
+  if (this.options.loose) {
+    // in loose mode, throw out any that are not valid comparators
+    set = set.filter(function (comp) {
+      return !!comp.match(compRe)
+    })
+  }
+  set = set.map(function (comp) {
+    return new Comparator(comp, this.options)
+  }, this)
+
+  return set
+}
+
+Range.prototype.intersects = function (range, options) {
+  if (!(range instanceof Range)) {
+    throw new TypeError('a Range is required')
+  }
+
+  return this.set.some(function (thisComparators) {
+    return thisComparators.every(function (thisComparator) {
+      return range.set.some(function (rangeComparators) {
+        return rangeComparators.every(function (rangeComparator) {
+          return thisComparator.intersects(rangeComparator, options)
+        })
+      })
+    })
+  })
+}
+
+// Mostly just for testing and legacy API reasons
+exports.toComparators = toComparators
+function toComparators (range, options) {
+  return new Range(range, options).set.map(function (comp) {
+    return comp.map(function (c) {
+      return c.value
+    }).join(' ').trim().split(' ')
+  })
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+function parseComparator (comp, options) {
+  debug('comp', comp, options)
+  comp = replaceCarets(comp, options)
+  debug('caret', comp)
+  comp = replaceTildes(comp, options)
+  debug('tildes', comp)
+  comp = replaceXRanges(comp, options)
+  debug('xrange', comp)
+  comp = replaceStars(comp, options)
+  debug('stars', comp)
+  return comp
+}
+
+function isX (id) {
+  return !id || id.toLowerCase() === 'x' || id === '*'
+}
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceTildes (comp, options) {
+  return comp.trim().split(/\s+/).map(function (comp) {
+    return replaceTilde(comp, options)
+  }).join(' ')
+}
+
+function replaceTilde (comp, options) {
+  var r = options.loose ? safeRe[TILDELOOSE] : safeRe[TILDE]
+  return comp.replace(r, function (_, M, m, p, pr) {
+    debug('tilde', comp, _, M, m, p, pr)
+    var ret
+
+    if (isX(M)) {
+      ret = ''
+    } else if (isX(m)) {
+      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
+    } else if (isX(p)) {
+      // ~1.2 == >=1.2.0 <1.3.0
+      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+    } else if (pr) {
+      debug('replaceTilde pr', pr)
+      ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+            ' <' + M + '.' + (+m + 1) + '.0'
+    } else {
+      // ~1.2.3 == >=1.2.3 <1.3.0
+      ret = '>=' + M + '.' + m + '.' + p +
+            ' <' + M + '.' + (+m + 1) + '.0'
+    }
+
+    debug('tilde return', ret)
+    return ret
+  })
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2.0 --> >=1.2.0 <2.0.0
+function replaceCarets (comp, options) {
+  return comp.trim().split(/\s+/).map(function (comp) {
+    return replaceCaret(comp, options)
+  }).join(' ')
+}
+
+function replaceCaret (comp, options) {
+  debug('caret', comp, options)
+  var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET]
+  return comp.replace(r, function (_, M, m, p, pr) {
+    debug('caret', comp, _, M, m, p, pr)
+    var ret
+
+    if (isX(M)) {
+      ret = ''
+    } else if (isX(m)) {
+      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
+    } else if (isX(p)) {
+      if (M === '0') {
+        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+      } else {
+        ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'
+      }
+    } else if (pr) {
+      debug('replaceCaret pr', pr)
+      if (M === '0') {
+        if (m === '0') {
+          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+                ' <' + M + '.' + m + '.' + (+p + 1)
+        } else {
+          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+                ' <' + M + '.' + (+m + 1) + '.0'
+        }
+      } else {
+        ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+              ' <' + (+M + 1) + '.0.0'
+      }
+    } else {
+      debug('no pr')
+      if (M === '0') {
+        if (m === '0') {
+          ret = '>=' + M + '.' + m + '.' + p +
+                ' <' + M + '.' + m + '.' + (+p + 1)
+        } else {
+          ret = '>=' + M + '.' + m + '.' + p +
+                ' <' + M + '.' + (+m + 1) + '.0'
+        }
+      } else {
+        ret = '>=' + M + '.' + m + '.' + p +
+              ' <' + (+M + 1) + '.0.0'
+      }
+    }
+
+    debug('caret return', ret)
+    return ret
+  })
+}
+
+function replaceXRanges (comp, options) {
+  debug('replaceXRanges', comp, options)
+  return comp.split(/\s+/).map(function (comp) {
+    return replaceXRange(comp, options)
+  }).join(' ')
+}
+
+function replaceXRange (comp, options) {
+  comp = comp.trim()
+  var r = options.loose ? safeRe[XRANGELOOSE] : safeRe[XRANGE]
+  return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
+    debug('xRange', comp, ret, gtlt, M, m, p, pr)
+    var xM = isX(M)
+    var xm = xM || isX(m)
+    var xp = xm || isX(p)
+    var anyX = xp
+
+    if (gtlt === '=' && anyX) {
+      gtlt = ''
+    }
+
+    if (xM) {
+      if (gtlt === '>' || gtlt === '<') {
+        // nothing is allowed
+        ret = '<0.0.0'
+      } else {
+        // nothing is forbidden
+        ret = '*'
+      }
+    } else if (gtlt && anyX) {
+      // we know patch is an x, because we have any x at all.
+      // replace X with 0
+      if (xm) {
+        m = 0
+      }
+      p = 0
+
+      if (gtlt === '>') {
+        // >1 => >=2.0.0
+        // >1.2 => >=1.3.0
+        // >1.2.3 => >= 1.2.4
+        gtlt = '>='
+        if (xm) {
+          M = +M + 1
+          m = 0
+          p = 0
+        } else {
+          m = +m + 1
+          p = 0
+        }
+      } else if (gtlt === '<=') {
+        // <=0.7.x is actually <0.8.0, since any 0.7.x should
+        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+        gtlt = '<'
+        if (xm) {
+          M = +M + 1
+        } else {
+          m = +m + 1
+        }
+      }
+
+      ret = gtlt + M + '.' + m + '.' + p
+    } else if (xm) {
+      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
+    } else if (xp) {
+      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+    }
+
+    debug('xRange return', ret)
+
+    return ret
+  })
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+function replaceStars (comp, options) {
+  debug('replaceStars', comp, options)
+  // Looseness is ignored here.  star is always as loose as it gets!
+  return comp.trim().replace(safeRe[STAR], '')
+}
+
+// This function is passed to string.replace(safeRe[HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0
+function hyphenReplace ($0,
+  from, fM, fm, fp, fpr, fb,
+  to, tM, tm, tp, tpr, tb) {
+  if (isX(fM)) {
+    from = ''
+  } else if (isX(fm)) {
+    from = '>=' + fM + '.0.0'
+  } else if (isX(fp)) {
+    from = '>=' + fM + '.' + fm + '.0'
+  } else {
+    from = '>=' + from
+  }
+
+  if (isX(tM)) {
+    to = ''
+  } else if (isX(tm)) {
+    to = '<' + (+tM + 1) + '.0.0'
+  } else if (isX(tp)) {
+    to = '<' + tM + '.' + (+tm + 1) + '.0'
+  } else if (tpr) {
+    to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr
+  } else {
+    to = '<=' + to
+  }
+
+  return (from + ' ' + to).trim()
+}
+
+// if ANY of the sets match ALL of its comparators, then pass
+Range.prototype.test = function (version) {
+  if (!version) {
+    return false
+  }
+
+  if (typeof version === 'string') {
+    version = new SemVer(version, this.options)
+  }
+
+  for (var i = 0; i < this.set.length; i++) {
+    if (testSet(this.set[i], version, this.options)) {
+      return true
+    }
+  }
+  return false
+}
+
+function testSet (set, version, options) {
+  for (var i = 0; i < set.length; i++) {
+    if (!set[i].test(version)) {
+      return false
+    }
+  }
+
+  if (version.prerelease.length && !options.includePrerelease) {
+    // Find the set of versions that are allowed to have prereleases
+    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+    // That should allow `1.2.3-pr.2` to pass.
+    // However, `1.2.4-alpha.notready` should NOT be allowed,
+    // even though it's within the range set by the comparators.
+    for (i = 0; i < set.length; i++) {
+      debug(set[i].semver)
+      if (set[i].semver === ANY) {
+        continue
+      }
+
+      if (set[i].semver.prerelease.length > 0) {
+        var allowed = set[i].semver
+        if (allowed.major === version.major &&
+            allowed.minor === version.minor &&
+            allowed.patch === version.patch) {
+          return true
+        }
+      }
+    }
+
+    // Version has a -pre, but it's not one of the ones we like.
+    return false
+  }
+
+  return true
+}
+
+exports.satisfies = satisfies
+function satisfies (version, range, options) {
+  try {
+    range = new Range(range, options)
+  } catch (er) {
+    return false
+  }
+  return range.test(version)
+}
+
+exports.maxSatisfying = maxSatisfying
+function maxSatisfying (versions, range, options) {
+  var max = null
+  var maxSV = null
+  try {
+    var rangeObj = new Range(range, options)
+  } catch (er) {
+    return null
+  }
+  versions.forEach(function (v) {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!max || maxSV.compare(v) === -1) {
+        // compare(max, v, true)
+        max = v
+        maxSV = new SemVer(max, options)
+      }
+    }
+  })
+  return max
+}
+
+exports.minSatisfying = minSatisfying
+function minSatisfying (versions, range, options) {
+  var min = null
+  var minSV = null
+  try {
+    var rangeObj = new Range(range, options)
+  } catch (er) {
+    return null
+  }
+  versions.forEach(function (v) {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!min || minSV.compare(v) === 1) {
+        // compare(min, v, true)
+        min = v
+        minSV = new SemVer(min, options)
+      }
+    }
+  })
+  return min
+}
+
+exports.minVersion = minVersion
+function minVersion (range, loose) {
+  range = new Range(range, loose)
+
+  var minver = new SemVer('0.0.0')
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = new SemVer('0.0.0-0')
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = null
+  for (var i = 0; i < range.set.length; ++i) {
+    var comparators = range.set[i]
+
+    comparators.forEach(function (comparator) {
+      // Clone to avoid manipulating the comparator's semver object.
+      var compver = new SemVer(comparator.semver.version)
+      switch (comparator.operator) {
+        case '>':
+          if (compver.prerelease.length === 0) {
+            compver.patch++
+          } else {
+            compver.prerelease.push(0)
+          }
+          compver.raw = compver.format()
+          /* fallthrough */
+        case '':
+        case '>=':
+          if (!minver || gt(minver, compver)) {
+            minver = compver
+          }
+          break
+        case '<':
+        case '<=':
+          /* Ignore maximum versions */
+          break
+        /* istanbul ignore next */
+        default:
+          throw new Error('Unexpected operation: ' + comparator.operator)
+      }
+    })
+  }
+
+  if (minver && range.test(minver)) {
+    return minver
+  }
+
+  return null
+}
+
+exports.validRange = validRange
+function validRange (range, options) {
+  try {
+    // Return '*' instead of '' so that truthiness works.
+    // This will throw if it's invalid anyway
+    return new Range(range, options).range || '*'
+  } catch (er) {
+    return null
+  }
+}
+
+// Determine if version is less than all the versions possible in the range
+exports.ltr = ltr
+function ltr (version, range, options) {
+  return outside(version, range, '<', options)
+}
+
+// Determine if version is greater than all the versions possible in the range.
+exports.gtr = gtr
+function gtr (version, range, options) {
+  return outside(version, range, '>', options)
+}
+
+exports.outside = outside
+function outside (version, range, hilo, options) {
+  version = new SemVer(version, options)
+  range = new Range(range, options)
+
+  var gtfn, ltefn, ltfn, comp, ecomp
+  switch (hilo) {
+    case '>':
+      gtfn = gt
+      ltefn = lte
+      ltfn = lt
+      comp = '>'
+      ecomp = '>='
+      break
+    case '<':
+      gtfn = lt
+      ltefn = gte
+      ltfn = gt
+      comp = '<'
+      ecomp = '<='
+      break
+    default:
+      throw new TypeError('Must provide a hilo val of "<" or ">"')
+  }
+
+  // If it satisifes the range it is not outside
+  if (satisfies(version, range, options)) {
+    return false
+  }
+
+  // From now on, variable terms are as if we're in "gtr" mode.
+  // but note that everything is flipped for the "ltr" function.
+
+  for (var i = 0; i < range.set.length; ++i) {
+    var comparators = range.set[i]
+
+    var high = null
+    var low = null
+
+    comparators.forEach(function (comparator) {
+      if (comparator.semver === ANY) {
+        comparator = new Comparator('>=0.0.0')
+      }
+      high = high || comparator
+      low = low || comparator
+      if (gtfn(comparator.semver, high.semver, options)) {
+        high = comparator
+      } else if (ltfn(comparator.semver, low.semver, options)) {
+        low = comparator
+      }
+    })
+
+    // If the edge version comparator has a operator then our version
+    // isn't outside it
+    if (high.operator === comp || high.operator === ecomp) {
+      return false
+    }
+
+    // If the lowest version comparator has an operator and our version
+    // is less than it then it isn't higher than the range
+    if ((!low.operator || low.operator === comp) &&
+        ltefn(version, low.semver)) {
+      return false
+    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+      return false
+    }
+  }
+  return true
+}
+
+exports.prerelease = prerelease
+function prerelease (version, options) {
+  var parsed = parse(version, options)
+  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+}
+
+exports.intersects = intersects
+function intersects (r1, r2, options) {
+  r1 = new Range(r1, options)
+  r2 = new Range(r2, options)
+  return r1.intersects(r2)
+}
+
+exports.coerce = coerce
+function coerce (version) {
+  if (version instanceof SemVer) {
+    return version
+  }
+
+  if (typeof version !== 'string') {
+    return null
+  }
+
+  var match = version.match(safeRe[COERCE])
+
+  if (match == null) {
+    return null
+  }
+
+  return parse(match[1] +
+    '.' + (match[2] || '0') +
+    '.' + (match[3] || '0'))
+}

adi-ui/.pnpm-store/v10/files/00/075c6eab99b64050356e43ccf2ed829004f297cc13e4c947f0b10d89b11891d0de4cc0387f3885f4cfbc434b10717daee21c7ecb3b81991aefe5a4773fa70b

@@ -0,0 +1 @@
+{"version":3,"file":"map.js","sources":["../../src/add/operator/map.ts"],"names":[],"mappings":";;AAAA,wCAAsC"}

adi-ui/.pnpm-store/v10/files/00/08db7085c7bbe7cb0ac8feda901022dd2a977e15a3dc031742378178037e98215294b7c18388f418daad47827b336f13ee32053b39d55867bd7b857d082939

@@ -0,0 +1,35 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+import ThemeRiverView from './ThemeRiverView.js';
+import ThemeRiverSeriesModel from './ThemeRiverSeries.js';
+import themeRiverLayout from './themeRiverLayout.js';
+import dataFilter from '../../processor/dataFilter.js';
+export function install(registers) {
+  registers.registerChartView(ThemeRiverView);
+  registers.registerSeriesModel(ThemeRiverSeriesModel);
+  registers.registerLayout(themeRiverLayout);
+  registers.registerProcessor(dataFilter('themeRiver'));
+}

adi-ui/.pnpm-store/v10/files/00/09310039dde3227905094369836f1779247dc3be817004d9af8478dbd7a3eeae8c8a6e292fe119bd4c6e0ae1ef72182f929c559c1ae9ba1426ce3d4314ef90

@@ -0,0 +1,101 @@
+function _sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _slicedToArray(arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return _sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var STOP = Symbol("STOP");
+
+function makeTransition(regex, nextState) {
+  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+      _ref$n = _ref.n,
+      n = _ref$n === void 0 ? 1 : _ref$n,
+      allowedSeparator = _ref.allowedSeparator;
+
+  return function (instance) {
+    if (allowedSeparator) {
+      if (instance.input[instance.ptr] === allowedSeparator) {
+        if (regex.test(instance.input.substring(instance.ptr - 1, instance.ptr))) {
+          // Consume the separator and stay in current state
+          return [instance.currentState, 1];
+        } else {
+          return [instance.terminatingState, 0];
+        }
+      }
+    }
+
+    if (regex.test(instance.input.substring(instance.ptr, instance.ptr + n))) {
+      return [nextState, n];
+    }
+
+    return false;
+  };
+}
+
+function combineTransitions(transitions) {
+  return function () {
+    var match = false;
+    var currentTransitions = transitions[this.currentState] || [];
+
+    for (var i = 0; i < currentTransitions.length; ++i) {
+      match = currentTransitions[i](this);
+
+      if (match !== false) {
+        break;
+      }
+    }
+
+    return match || [this.terminatingState, 0];
+  };
+}
+
+var FSM =
+/*#__PURE__*/
+function () {
+  function FSM(transitions, initialState) {
+    var terminatingState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : STOP;
+
+    _classCallCheck(this, FSM);
+
+    this.initialState = initialState;
+    this.terminatingState = terminatingState;
+
+    if (terminatingState === STOP || !transitions[terminatingState]) {
+      transitions[terminatingState] = [];
+    }
+
+    this.transitionFunction = combineTransitions.call(this, transitions);
+  }
+
+  _createClass(FSM, [{
+    key: "run",
+    value: function run(input) {
+      this.input = input;
+      this.ptr = 0;
+      this.currentState = this.initialState;
+      var value = "";
+      var eatLength, nextState;
+
+      while (this.currentState !== this.terminatingState && this.ptr < this.input.length) {
+        var _transitionFunction = this.transitionFunction();
+
+        var _transitionFunction2 = _slicedToArray(_transitionFunction, 2);
+
+        nextState = _transitionFunction2[0];
+        eatLength = _transitionFunction2[1];
+        value += this.input.substring(this.ptr, this.ptr += eatLength);
+        this.currentState = nextState;
+      }
+
+      return value;
+    }
+  }]);
+
+  return FSM;
+}();
+
+export { makeTransition, FSM };

adi-ui/.pnpm-store/v10/files/00/0af4fc03d2ecf7155b911e07941ea071519cc573fc911548cdad0701587a3617d6dc9954610260c3d1c421adc4799ccec5835ec14b994d5fc5baa8a6f83e0a

@@ -0,0 +1,34 @@
+var baseHasIn = require('./_baseHasIn'),
+    hasPath = require('./_hasPath');
+
+/**
+ * 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);
+}
+
+module.exports = hasIn;

adi-ui/.pnpm-store/v10/files/00/0b613f9724c5da0532eb3b34ef74d966db5f9efd5d12e0f50fe5f47c899e039959b560b597907c0cac4c3107da46144bd735b44a120a27aa08de61d0a033bd

@@ -0,0 +1,201 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const ResolverFactory = require("./ResolverFactory");
+
+const NodeJsInputFileSystem = require("./NodeJsInputFileSystem");
+const CachedInputFileSystem = require("./CachedInputFileSystem");
+
+const nodeFileSystem = new CachedInputFileSystem(
+	new NodeJsInputFileSystem(),
+	4000
+);
+
+const nodeContext = {
+	environments: ["node+es3+es5+process+native"]
+};
+
+const asyncResolver = ResolverFactory.createResolver({
+	extensions: [".js", ".json", ".node"],
+	fileSystem: nodeFileSystem
+});
+module.exports = function resolve(
+	context,
+	path,
+	request,
+	resolveContext,
+	callback
+) {
+	if (typeof context === "string") {
+		callback = resolveContext;
+		resolveContext = request;
+		request = path;
+		path = context;
+		context = nodeContext;
+	}
+	if (typeof callback !== "function") {
+		callback = resolveContext;
+	}
+	asyncResolver.resolve(context, path, request, resolveContext, callback);
+};
+
+const syncResolver = ResolverFactory.createResolver({
+	extensions: [".js", ".json", ".node"],
+	useSyncFileSystemCalls: true,
+	fileSystem: nodeFileSystem
+});
+module.exports.sync = function resolveSync(context, path, request) {
+	if (typeof context === "string") {
+		request = path;
+		path = context;
+		context = nodeContext;
+	}
+	return syncResolver.resolveSync(context, path, request);
+};
+
+const asyncContextResolver = ResolverFactory.createResolver({
+	extensions: [".js", ".json", ".node"],
+	resolveToContext: true,
+	fileSystem: nodeFileSystem
+});
+module.exports.context = function resolveContext(
+	context,
+	path,
+	request,
+	resolveContext,
+	callback
+) {
+	if (typeof context === "string") {
+		callback = resolveContext;
+		resolveContext = request;
+		request = path;
+		path = context;
+		context = nodeContext;
+	}
+	if (typeof callback !== "function") {
+		callback = resolveContext;
+	}
+	asyncContextResolver.resolve(
+		context,
+		path,
+		request,
+		resolveContext,
+		callback
+	);
+};
+
+const syncContextResolver = ResolverFactory.createResolver({
+	extensions: [".js", ".json", ".node"],
+	resolveToContext: true,
+	useSyncFileSystemCalls: true,
+	fileSystem: nodeFileSystem
+});
+module.exports.context.sync = function resolveContextSync(
+	context,
+	path,
+	request
+) {
+	if (typeof context === "string") {
+		request = path;
+		path = context;
+		context = nodeContext;
+	}
+	return syncContextResolver.resolveSync(context, path, request);
+};
+
+const asyncLoaderResolver = ResolverFactory.createResolver({
+	extensions: [".js", ".json", ".node"],
+	moduleExtensions: ["-loader"],
+	mainFields: ["loader", "main"],
+	fileSystem: nodeFileSystem
+});
+module.exports.loader = function resolveLoader(
+	context,
+	path,
+	request,
+	resolveContext,
+	callback
+) {
+	if (typeof context === "string") {
+		callback = resolveContext;
+		resolveContext = request;
+		request = path;
+		path = context;
+		context = nodeContext;
+	}
+	if (typeof callback !== "function") {
+		callback = resolveContext;
+	}
+	asyncLoaderResolver.resolve(context, path, request, resolveContext, callback);
+};
+
+const syncLoaderResolver = ResolverFactory.createResolver({
+	extensions: [".js", ".json", ".node"],
+	moduleExtensions: ["-loader"],
+	mainFields: ["loader", "main"],
+	useSyncFileSystemCalls: true,
+	fileSystem: nodeFileSystem
+});
+module.exports.loader.sync = function resolveLoaderSync(
+	context,
+	path,
+	request
+) {
+	if (typeof context === "string") {
+		request = path;
+		path = context;
+		context = nodeContext;
+	}
+	return syncLoaderResolver.resolveSync(context, path, request);
+};
+
+module.exports.create = function create(options) {
+	options = Object.assign(
+		{
+			fileSystem: nodeFileSystem
+		},
+		options
+	);
+	const resolver = ResolverFactory.createResolver(options);
+	return function(context, path, request, resolveContext, callback) {
+		if (typeof context === "string") {
+			callback = resolveContext;
+			resolveContext = request;
+			request = path;
+			path = context;
+			context = nodeContext;
+		}
+		if (typeof callback !== "function") {
+			callback = resolveContext;
+		}
+		resolver.resolve(context, path, request, resolveContext, callback);
+	};
+};
+
+module.exports.create.sync = function createSync(options) {
+	options = Object.assign(
+		{
+			useSyncFileSystemCalls: true,
+			fileSystem: nodeFileSystem
+		},
+		options
+	);
+	const resolver = ResolverFactory.createResolver(options);
+	return function(context, path, request) {
+		if (typeof context === "string") {
+			request = path;
+			path = context;
+			context = nodeContext;
+		}
+		return resolver.resolveSync(context, path, request);
+	};
+};
+
+// Export Resolver, FileSystems and Plugins
+module.exports.ResolverFactory = ResolverFactory;
+
+module.exports.NodeJsInputFileSystem = NodeJsInputFileSystem;
+module.exports.CachedInputFileSystem = CachedInputFileSystem;

adi-ui/.pnpm-store/v10/files/00/0d44e021ba4d507988e39038cefa0664566046a268271b9e557332501d7a7213d2bd7699a2f74025238f3aaf35f6e6f18d823a499dd59a7a302315425a68f0

@@ -0,0 +1,10 @@
+'use strict';
+var isPrototypeOf = require('../../internals/object-is-prototype-of');
+var method = require('../array/virtual/to-sorted');
+
+var ArrayPrototype = Array.prototype;
+
+module.exports = function (it) {
+  var own = it.toSorted;
+  return (it === ArrayPrototype || (isPrototypeOf(ArrayPrototype, it) && own === ArrayPrototype.toSorted)) ? method : own;
+};

adi-ui/.pnpm-store/v10/files/00/145d81f718f0c9e5a2de79ddd90ce7dc0256de27d7d826931df6066d3ba35ab15c0ed794822aa08de728796c9d5cdddf0c7d5a51815811c620bcd81bce20a7

@@ -0,0 +1,29 @@
+{
+  "name": "stream-each",
+  "version": "1.2.3",
+  "description": "Iterate all the data in a stream",
+  "main": "index.js",
+  "dependencies": {
+    "end-of-stream": "^1.1.0",
+    "stream-shift": "^1.0.0"
+  },
+  "devDependencies": {
+    "ndjson": "^1.5.0",
+    "standard": "^5.3.1",
+    "tape": "^4.2.1",
+    "through2": "^2.0.0"
+  },
+  "scripts": {
+    "test": "standard && tape test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mafintosh/stream-each.git"
+  },
+  "author": "Mathias Buus (@mafintosh)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mafintosh/stream-each/issues"
+  },
+  "homepage": "https://github.com/mafintosh/stream-each"
+}

adi-ui/.pnpm-store/v10/files/00/1964986d531b57f13008a726001a1e7999d284cf8d03725c57160bc19406a20f8c508b10f838f325f2584daafdbc996c2dc6b0a82a0a8d67ec53898625d83c

@@ -0,0 +1,2 @@
+var convert = require('./convert');
+module.exports = convert(require('../function'));

adi-ui/.pnpm-store/v10/files/00/1a4e22b79ad30d84b67c5e2f8fc8f6465ffb172daece482eb48c652bda52febb6e00432baf70fee03e86459c4035fa3b701603fb208d836ba65d8511fbb1d4

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../../actual/instance/flat-map');
+
+module.exports = parent;

adi-ui/.pnpm-store/v10/files/00/1ab7d6d049acc26f76463bacfc136eae237177fceead06850ea1bae98458b406be004eb51695637a86d5067b9a5ee429301b26ec116e9481b42d5cd9e6db24

@@ -0,0 +1,2 @@
+import GlobalModel from '../../model/Global.js';
+export default function sankeyVisual(ecModel: GlobalModel): void;

adi-ui/.pnpm-store/v10/files/00/1b98e729d0e1415b009bdbf9fbea3afab80b1458ba2bdf775079215fcd356feac118a2c92eeeb04f24c38d7890493f3999f07a1585b9c97f7be1769c0b9142

@@ -0,0 +1,102 @@
+import { AjaxRequest } from './types';
+import { getXHRResponse } from './getXHRResponse';
+import { createErrorClass } from '../util/createErrorClass';
+
+/**
+ * A normalized AJAX error.
+ *
+ * @see {@link ajax}
+ */
+export interface AjaxError extends Error {
+  /**
+   * The XHR instance associated with the error.
+   */
+  xhr: XMLHttpRequest;
+
+  /**
+   * The AjaxRequest associated with the error.
+   */
+  request: AjaxRequest;
+
+  /**
+   * The HTTP status code, if the request has completed. If not,
+   * it is set to `0`.
+   */
+  status: number;
+
+  /**
+   * The responseType (e.g. 'json', 'arraybuffer', or 'xml').
+   */
+  responseType: XMLHttpRequestResponseType;
+
+  /**
+   * The response data.
+   */
+  response: any;
+}
+
+export interface AjaxErrorCtor {
+  /**
+   * @deprecated Internal implementation detail. Do not construct error instances.
+   * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+   */
+  new (message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError;
+}
+
+/**
+ * Thrown when an error occurs during an AJAX request.
+ * This is only exported because it is useful for checking to see if an error
+ * is an `instanceof AjaxError`. DO NOT create new instances of `AjaxError` with
+ * the constructor.
+ *
+ * @see {@link ajax}
+ */
+export const AjaxError: AjaxErrorCtor = createErrorClass(
+  (_super) =>
+    function AjaxErrorImpl(this: any, message: string, xhr: XMLHttpRequest, request: AjaxRequest) {
+      this.message = message;
+      this.name = 'AjaxError';
+      this.xhr = xhr;
+      this.request = request;
+      this.status = xhr.status;
+      this.responseType = xhr.responseType;
+      let response: any;
+      try {
+        // This can throw in IE, because we have to do a JSON.parse of
+        // the response in some cases to get the expected response property.
+        response = getXHRResponse(xhr);
+      } catch (err) {
+        response = xhr.responseText;
+      }
+      this.response = response;
+    }
+);
+
+export interface AjaxTimeoutError extends AjaxError {}
+
+export interface AjaxTimeoutErrorCtor {
+  /**
+   * @deprecated Internal implementation detail. Do not construct error instances.
+   * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+   */
+  new (xhr: XMLHttpRequest, request: AjaxRequest): AjaxTimeoutError;
+}
+
+/**
+ * Thrown when an AJAX request times out. Not to be confused with {@link TimeoutError}.
+ *
+ * This is exported only because it is useful for checking to see if errors are an
+ * `instanceof AjaxTimeoutError`. DO NOT use the constructor to create an instance of
+ * this type.
+ *
+ * @see {@link ajax}
+ */
+export const AjaxTimeoutError: AjaxTimeoutErrorCtor = (() => {
+  function AjaxTimeoutErrorImpl(this: any, xhr: XMLHttpRequest, request: AjaxRequest) {
+    AjaxError.call(this, 'ajax timeout', xhr, request);
+    this.name = 'AjaxTimeoutError';
+    return this;
+  }
+  AjaxTimeoutErrorImpl.prototype = Object.create(AjaxError.prototype);
+  return AjaxTimeoutErrorImpl;
+})() as any;

adi-ui/.pnpm-store/v10/files/00/1bd318b4f0e816c9ded28091d256ae7ff7d3b0e9ff3b262376377857e0801e53b59d3ea434c2e032cd746ed135c655b1479cafe5e4473c7fbb224ae36f4ae8

@@ -0,0 +1,39 @@
+/**
+Check if [`argv`](https://nodejs.org/docs/latest/api/process.html#process_process_argv) has a specific flag.
+
+@param flag - CLI flag to look for. The `--` prefix is optional.
+@param argv - CLI arguments. Default: `process.argv`.
+@returns Whether the flag exists.
+
+@example
+```
+// $ ts-node foo.ts -f --unicorn --foo=bar -- --rainbow
+
+// foo.ts
+import hasFlag = require('has-flag');
+
+hasFlag('unicorn');
+//=> true
+
+hasFlag('--unicorn');
+//=> true
+
+hasFlag('f');
+//=> true
+
+hasFlag('-f');
+//=> true
+
+hasFlag('foo=bar');
+//=> true
+
+hasFlag('foo');
+//=> false
+
+hasFlag('rainbow');
+//=> false
+```
+*/
+declare function hasFlag(flag: string, argv?: string[]): boolean;
+
+export = hasFlag;

adi-ui/.pnpm-store/v10/files/00/1fc59cd022779599363bdaf4c68ddbf995372d97e184b7696a2d80f9e3ff0446cc343a1c34510d1d15540cfe726ccb2963b3c9cb52d7a1352d4e496c5c55b3

@@ -0,0 +1,36 @@
+'use strict';
+
+require('../auto');
+
+var runTests = require('./tests');
+
+var test = require('tape');
+var defineProperties = require('define-properties');
+var callBind = require('call-bind');
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+var functionsHaveNames = require('functions-have-names')();
+
+test('shimmed', function (t) {
+	t.equal(String.prototype.trimEnd.length, 0, 'String#trimEnd has a length of 0');
+	t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+		st.equal((/^(?:trimRight|trimEnd)$/).test(String.prototype.trimEnd.name), true, 'String#trimEnd has name "trimRight" or "trimEnd"');
+		st.end();
+	});
+
+	t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+		et.equal(false, isEnumerable.call(String.prototype, 'trimEnd'), 'String#trimEnd is not enumerable');
+		et.end();
+	});
+
+	var supportsStrictMode = (function () { return typeof this === 'undefined'; }());
+
+	t.test('bad string/this value', { skip: !supportsStrictMode }, function (st) {
+		st['throws'](function () { return String.prototype.trimEnd.call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+		st['throws'](function () { return String.prototype.trimEnd.call(null, 'a'); }, TypeError, 'null is not an object');
+		st.end();
+	});
+
+	runTests(callBind(String.prototype.trimEnd), t);
+
+	t.end();
+});

adi-ui/.pnpm-store/v10/files/00/20f7580ea8caddb5e6aee7c6c71334ec46f81147fae255e551927118d9eeb6e2d3f6d7ba510cbceff55dab563f64e22ab8fb082af677d5487cdd5b084bc2ed

@@ -0,0 +1,70 @@
+/**
+ * Single coordinates system.
+ */
+import SingleAxis from './SingleAxis.js';
+import { CoordinateSystem, CoordinateSystemMaster } from '../CoordinateSystem.js';
+import GlobalModel from '../../model/Global.js';
+import ExtensionAPI from '../../core/ExtensionAPI.js';
+import BoundingRect from 'zrender/lib/core/BoundingRect.js';
+import SingleAxisModel from './AxisModel.js';
+import { ParsedModelFinder } from '../../util/model.js';
+import { ScaleDataValue } from '../../util/types.js';
+export declare const singleDimensions: string[];
+/**
+ * Create a single coordinates system.
+ */
+declare class Single implements CoordinateSystem, CoordinateSystemMaster {
+    readonly type = "single";
+    readonly dimension = "single";
+    /**
+     * Add it just for draw tooltip.
+     */
+    readonly dimensions: string[];
+    name: string;
+    axisPointerEnabled: boolean;
+    model: SingleAxisModel;
+    private _axis;
+    private _rect;
+    constructor(axisModel: SingleAxisModel, ecModel: GlobalModel, api: ExtensionAPI);
+    /**
+     * Initialize single coordinate system.
+     */
+    _init(axisModel: SingleAxisModel, ecModel: GlobalModel, api: ExtensionAPI): void;
+    /**
+     * Update axis scale after data processed
+     */
+    update(ecModel: GlobalModel, api: ExtensionAPI): void;
+    /**
+     * Resize the single coordinate system.
+     */
+    resize(axisModel: SingleAxisModel, api: ExtensionAPI): void;
+    getRect(): BoundingRect;
+    private _adjustAxis;
+    private _updateAxisTransform;
+    /**
+     * Get axis.
+     */
+    getAxis(): SingleAxis;
+    /**
+     * Get axis, add it just for draw tooltip.
+     */
+    getBaseAxis(): SingleAxis;
+    getAxes(): SingleAxis[];
+    getTooltipAxes(): {
+        baseAxes: SingleAxis[];
+        otherAxes: SingleAxis[];
+    };
+    /**
+     * If contain point.
+     */
+    containPoint(point: number[]): boolean;
+    pointToData(point: number[]): number[];
+    /**
+     * Convert the series data to concrete point.
+     * Can be [val] | val
+     */
+    dataToPoint(val: ScaleDataValue | ScaleDataValue[]): number[];
+    convertToPixel(ecModel: GlobalModel, finder: ParsedModelFinder, value: ScaleDataValue[]): number[];
+    convertFromPixel(ecModel: GlobalModel, finder: ParsedModelFinder, pixel: number[]): number[];
+}
+export default Single;

adi-ui/.pnpm-store/v10/files/00/22005e09996870d80fea9292303571c4b5e1556b8400f2806fa34e0263a12897e29c9ad5703e5f4f2c217db8d1ed92fa9709f3187254d3a3564ae96a79d7f9

@@ -0,0 +1,5 @@
+'use strict';
+var parent = require('../../stable/set/is-disjoint-from');
+require('../../modules/esnext.set.is-disjoint-from.v2');
+
+module.exports = parent;

adi-ui/.pnpm-store/v10/files/00/24285bdc7c34ca5287d514f0197bd9acdc4c31f83d36dcbed73d8f2562adf2599dc5580f291d8e4683f7857f04fde8ea58b89653800e9f1cf30517f6cc7c00

@@ -0,0 +1,127 @@
+/**
+ * @fileoverview Rule to disallow negating the left operand of relational operators
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether the given operator is `in` or `instanceof`
+ * @param {string} op The operator type to check.
+ * @returns {boolean} `true` if the operator is `in` or `instanceof`
+ */
+function isInOrInstanceOfOperator(op) {
+    return op === "in" || op === "instanceof";
+}
+
+/**
+ * Checks whether the given operator is an ordering relational operator or not.
+ * @param {string} op The operator type to check.
+ * @returns {boolean} `true` if the operator is an ordering relational operator.
+ */
+function isOrderingRelationalOperator(op) {
+    return op === "<" || op === ">" || op === ">=" || op === "<=";
+}
+
+/**
+ * Checks whether the given node is a logical negation expression or not.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is a logical negation expression.
+ */
+function isNegation(node) {
+    return node.type === "UnaryExpression" && node.operator === "!";
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow negating the left operand of relational operators",
+            category: "Possible Errors",
+            recommended: true,
+            url: "https://eslint.org/docs/rules/no-unsafe-negation",
+            suggestion: true
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    enforceForOrderingRelations: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+
+        fixable: null,
+
+        messages: {
+            unexpected: "Unexpected negating the left operand of '{{operator}}' operator.",
+            suggestNegatedExpression: "Negate '{{operator}}' expression instead of its left operand. This changes the current behavior.",
+            suggestParenthesisedNegation: "Wrap negation in '()' to make the intention explicit. This preserves the current behavior."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        const options = context.options[0] || {};
+        const enforceForOrderingRelations = options.enforceForOrderingRelations === true;
+
+        return {
+            BinaryExpression(node) {
+                const operator = node.operator;
+                const orderingRelationRuleApplies = enforceForOrderingRelations && isOrderingRelationalOperator(operator);
+
+                if (
+                    (isInOrInstanceOfOperator(operator) || orderingRelationRuleApplies) &&
+                    isNegation(node.left) &&
+                    !astUtils.isParenthesised(sourceCode, node.left)
+                ) {
+                    context.report({
+                        node,
+                        loc: node.left.loc,
+                        messageId: "unexpected",
+                        data: { operator },
+                        suggest: [
+                            {
+                                messageId: "suggestNegatedExpression",
+                                data: { operator },
+                                fix(fixer) {
+                                    const negationToken = sourceCode.getFirstToken(node.left);
+                                    const fixRange = [negationToken.range[1], node.range[1]];
+                                    const text = sourceCode.text.slice(fixRange[0], fixRange[1]);
+
+                                    return fixer.replaceTextRange(fixRange, `(${text})`);
+                                }
+                            },
+                            {
+                                messageId: "suggestParenthesisedNegation",
+                                fix(fixer) {
+                                    return fixer.replaceText(node.left, `(${sourceCode.getText(node.left)})`);
+                                }
+                            }
+                        ]
+                    });
+                }
+            }
+        };
+    }
+};

adi-ui/.pnpm-store/v10/files/00/26f39796b1675e13ffccdc0da8b12f5dd0a009655a6d707fa61d9d107ab2e415849eb9ff7a51cb02b0e0dbb970ad7a554ed2b4ee50dfd472e7da1a86a82e69

@@ -0,0 +1,3 @@
+require('../modules/es7.weak-map.of');
+require('../modules/es7.weak-map.from');
+module.exports = require('../modules/_core').WeakMap;

adi-ui/.pnpm-store/v10/files/00/282fb6064a43614c483c9eb6c9edba982d6fc68a3e0b9c7bd5e771f9edc21b21f79a73da73e7041fcd5e971300cb13a20f01dc8fad2ec18a90486caf99df14

@@ -0,0 +1,61 @@
+import { Observable } from '../Observable';
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
+ * calls `error`, this method will emit the Throwable that caused the error to the `ObservableInput` returned from `notifier`.
+ * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child
+ * subscription. Otherwise this method will resubscribe to the source Observable.
+ *
+ * ![](retryWhen.png)
+ *
+ * Retry an observable sequence on error based on custom criteria.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { interval, map, retryWhen, tap, delayWhen, timer } from 'rxjs';
+ *
+ * const source = interval(1000);
+ * const result = source.pipe(
+ *   map(value => {
+ *     if (value > 5) {
+ *       // error will be picked up by retryWhen
+ *       throw value;
+ *     }
+ *     return value;
+ *   }),
+ *   retryWhen(errors =>
+ *     errors.pipe(
+ *       // log error message
+ *       tap(value => console.log(`Value ${ value } was too high!`)),
+ *       // restart in 5 seconds
+ *       delayWhen(value => timer(value * 1000))
+ *     )
+ *   )
+ * );
+ *
+ * result.subscribe(value => console.log(value));
+ *
+ * // results:
+ * // 0
+ * // 1
+ * // 2
+ * // 3
+ * // 4
+ * // 5
+ * // 'Value 6 was too high!'
+ * // - Wait 5 seconds then repeat
+ * ```
+ *
+ * @see {@link retry}
+ *
+ * @param notifier Function that receives an Observable of notifications with which a
+ * user can `complete` or `error`, aborting the retry.
+ * @return A function that returns an Observable that mirrors the source
+ * Observable with the exception of an `error`.
+ * @deprecated Will be removed in v9 or v10, use {@link retry}'s `delay` option instead.
+ * Will be removed in v9 or v10. Use {@link retry}'s {@link RetryConfig#delay delay} option instead.
+ * Instead of `retryWhen(() => notify$)`, use: `retry({ delay: () => notify$ })`.
+ */
+export declare function retryWhen<T>(notifier: (errors: Observable<any>) => ObservableInput<any>): MonoTypeOperatorFunction<T>;
+//# sourceMappingURL=retryWhen.d.ts.map

adi-ui/.pnpm-store/v10/files/00/2cb91afa9c4f4c2c531f0d35e28f8c676162fa05a9b8abee3069548b70c8bd8a8fa4a68956dae1cb963a39f2f102b7566a2d0a7f254433658a2d1773606a28

@@ -0,0 +1 @@
+module.exports={A:{A:{"1":"E F A B","2":"K D oC"},B:{"1":"0 9 C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB"},C:{"1":"0 1 2 3 4 5 6 7 8 9 NC J RB K D E F A B C L M G N O P SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB OC yB PC zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q H R QC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB GC RC SC qC rC sC tC","132":"pC"},D:{"1":"0 1 2 3 4 5 6 7 8 9 J RB K D E F A B C L M G N O P SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB OC yB PC zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB GC RC SC"},E:{"1":"J RB K D E F A B C L M G uC TC vC wC xC yC UC HC IC zC 0C 1C VC WC JC 2C KC XC YC ZC aC bC 3C LC cC dC eC fC gC 4C MC hC iC jC kC lC 5C"},F:{"1":"0 1 2 3 4 5 6 7 8 F B C G N O P SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q H R QC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 6C 7C 8C 9C HC mC AD IC"},G:{"1":"E TC BD nC CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD TD UD VC WC JC VD KC XC YC ZC aC bC WD LC cC dC eC fC gC XD MC hC iC jC kC lC"},H:{"1":"YD"},I:{"1":"NC J I ZD aD bD cD nC dD eD"},J:{"1":"D A"},K:{"1":"A B C H HC mC IC"},L:{"1":"I"},M:{"1":"GC"},N:{"1":"A B"},O:{"1":"JC"},P:{"1":"1 2 3 4 5 6 7 8 J fD gD hD iD jD UC kD lD mD nD oD KC LC MC pD"},Q:{"1":"qD"},R:{"1":"rD"},S:{"1":"sD tD"}},B:2,C:"CSS Table display",D:true};

adi-ui/.pnpm-store/v10/files/00/3072abd328dc75b381dfca54581b0a16297fc951f75846a87c1de287dbd403cf1333419e2cb2e56ee885c20a5e219980c78c01fb0f8e2fa23cbbcddd0bf2a9

@@ -0,0 +1,66 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [v1.0.6](https://github.com/browserify/cipher-base/compare/v1.0.5...v1.0.6) - 2024-11-26
+
+### Commits
+
+- [Fix] io.js 3.0 - Node.js 5.3 typed array support [`b7ddd2a`](https://github.com/browserify/cipher-base/commit/b7ddd2ac24e65cc47befc1e0eb5026422f8ab037)
+
+## [v1.0.5](https://github.com/browserify/cipher-base/compare/v1.0.4...v1.0.5) - 2024-11-17
+
+### Commits
+
+- [Tests] standard -> eslint, make test dir, etc [`ae02fd6`](https://github.com/browserify/cipher-base/commit/ae02fd6624c41ac4ac18077be797111d1955bc76)
+- [Tests] migrate from travis to GHA [`66387d7`](https://github.com/browserify/cipher-base/commit/66387d71461287ad9067bb1bcbfdc47403a33ee7)
+- [meta] fix package.json indentation [`5c02918`](https://github.com/browserify/cipher-base/commit/5c02918ac58c875ed36913c2dc3e1043f4d1c99c)
+- [Fix] return valid values on multi-byte-wide TypedArray input [`8fd1364`](https://github.com/browserify/cipher-base/commit/8fd136432ca298a664f5637629cf2b42a6c7f294)
+- [meta] add `auto-changelog` [`88dc806`](https://github.com/browserify/cipher-base/commit/88dc806806d3dc41444dbf639c87c00f82c949b3)
+- [meta] add `npmignore` and `safe-publish-latest` [`7a137d7`](https://github.com/browserify/cipher-base/commit/7a137d749ce7ea7ea56b9c096844b1b8ab723f61)
+- Only apps should have lockfiles [`42528f2`](https://github.com/browserify/cipher-base/commit/42528f291db16bf2e7d5f831ebe2ad87fd0b1f42)
+- [Deps] update `inherits`, `safe-buffer` [`0e7a2d9`](https://github.com/browserify/cipher-base/commit/0e7a2d9a33a391e82fa9cf512d6e25cc91ab8613)
+- [meta] add missing `engines.node` [`f2dc13e`](https://github.com/browserify/cipher-base/commit/f2dc13e47bbcf3c873db9a9e0f83e5f29d0783fe)
+
+## [v1.0.4](https://github.com/browserify/cipher-base/compare/v1.0.3...v1.0.4) - 2017-07-06
+
+### Merged
+
+- Safe Buffer & License [`#8`](https://github.com/browserify/cipher-base/pull/8)
+- fix break in node 8 [`#9`](https://github.com/browserify/cipher-base/pull/9)
+
+### Commits
+
+- use safe-buffer [`193bbeb`](https://github.com/browserify/cipher-base/commit/193bbeb0d60ff206b072d4e18b32fcf150eb0fad)
+- add MIT LICENSE [`a9fb6e3`](https://github.com/browserify/cipher-base/commit/a9fb6e316c25b25d2bd04fa5b6eb748318bdcb04)
+- index: add missing Buffer.alloc [`2397a9e`](https://github.com/browserify/cipher-base/commit/2397a9e0db33b2f3d6abbd89f01db1c066804a91)
+- rename README to README, add .gitignore [`9345e1d`](https://github.com/browserify/cipher-base/commit/9345e1d21fd10555bc4f39ccae5512ca0202c5f6)
+
+## [v1.0.3](https://github.com/browserify/cipher-base/compare/v1.0.2...v1.0.3) - 2016-09-13
+
+### Merged
+
+- closure-compiler fix - final is a reserved word [`#4`](https://github.com/browserify/cipher-base/pull/4)
+
+## [v1.0.2](https://github.com/browserify/cipher-base/compare/v1.0.1...v1.0.2) - 2015-10-23
+
+### Merged
+
+- fix up typo in README [`#1`](https://github.com/browserify/cipher-base/pull/1)
+
+### Commits
+
+- Update api-methods. [`c4a7156`](https://github.com/browserify/cipher-base/commit/c4a7156c7beedb524ce5005374d2fd1327fa3ca4)
+- travis [`a5873f7`](https://github.com/browserify/cipher-base/commit/a5873f7dbfe542d7ec28bcb3e306096d1d2b951c)
+- Add api-methods [`208b338`](https://github.com/browserify/cipher-base/commit/208b33841d3e8a6f5322e54bdf442e1ee0d77590)
+- Update error messages [`dc19a24`](https://github.com/browserify/cipher-base/commit/dc19a24119786518c1c835d948e36ddae3bf3adb)
+
+## v1.0.1 - 2015-09-26
+
+### Commits
+
+- first [`8fbd9e7`](https://github.com/browserify/cipher-base/commit/8fbd9e7654d384b578e63d12e0311ae16dc07741)
+- fix error in 0.10 [`61491fe`](https://github.com/browserify/cipher-base/commit/61491fe31fcc9bee0901f93b26cee6eaaca07575)

adi-ui/.pnpm-store/v10/files/00/35234b6b5bb8e881488bd83e5745f5fb023f468f48b666923df36922c99daf5f2e98d352d8b08b8a337adf9912cac0282199a5798d0143383f9fdcc963cafc

@@ -0,0 +1,13 @@
+{
+  "name": "@webassemblyjs/helper-fsm",
+  "version": "1.9.0",
+  "description": "FSM implementation",
+  "main": "lib/index.js",
+  "module": "esm/index.js",
+  "author": "Mauro Bringolf",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "0440b420888c1f7701eb9762ec657775506b87d8"
+}

adi-ui/.pnpm-store/v10/files/00/358a98ebfc5f002d81dba724affd650340bfa0796bef02868fbc94e81cd69c4be7a7e87c324ac43285c4eac8abd61dfd12099a280302bef6ee5b14fd8d0b03

@@ -0,0 +1,5 @@
+var convert = require('./convert'),
+    func = convert('defaultsAll', require('../defaults'));
+
+func.placeholder = require('./placeholder');
+module.exports = func;

adi-ui/.pnpm-store/v10/files/00/3c67e00e623ec641666e5d7f0b2d4a618cda38a462fe22ec6ce2f189a65345f20fd0ae6387f03682ce16bcb263ed9d39a90debf39c6ebb9db49822059383ce

@@ -0,0 +1 @@
+# tty-browserify

adi-ui/.pnpm-store/v10/files/00/42f9acb00fdccd9934b3aa5bc11e49fbbfaedcab6a3945384e159da74217936fdabdc07dd6c57dd86c21c19eae64fa929b6627ce7b5c177738926facb12cbf

@@ -0,0 +1,2 @@
+'use strict';
+module.exports = require('../../full/array/splice');

adi-ui/.pnpm-store/v10/files/00/43a640e8fe6a54ccf7d93d55711cb47e94ba1184b414bcf9000e66596b03ae58529c78d7ec91034d395a7514ed0b48c9c1d9b0986a36ef640263f4815f6f51

@@ -0,0 +1,18 @@
+'use strict';
+
+function isDDS(buffer){
+	return buffer.readUInt32LE(0) === 0x20534444;
+}
+
+function calculate(buffer){
+	// read file resolution metadata
+	return {
+		'height': buffer.readUInt32LE(12),
+		'width': buffer.readUInt32LE(16)
+	};
+}
+
+module.exports = {
+	'detect': isDDS,
+	'calculate': calculate
+};

adi-ui/.pnpm-store/v10/files/00/44e7c43527a86f6f116069d2b4dd72c13411a7164ae8f818f99be28fd31d5b9505376248fcf14c6516bb3e611aa41120aaf96165dd45098985f0899b50c205

@@ -0,0 +1,35 @@
+const unicode = require('../lib/unicode')
+
+module.exports = {
+    isSpaceSeparator (c) {
+        return typeof c === 'string' && unicode.Space_Separator.test(c)
+    },
+
+    isIdStartChar (c) {
+        return typeof c === 'string' && (
+            (c >= 'a' && c <= 'z') ||
+        (c >= 'A' && c <= 'Z') ||
+        (c === '$') || (c === '_') ||
+        unicode.ID_Start.test(c)
+        )
+    },
+
+    isIdContinueChar (c) {
+        return typeof c === 'string' && (
+            (c >= 'a' && c <= 'z') ||
+        (c >= 'A' && c <= 'Z') ||
+        (c >= '0' && c <= '9') ||
+        (c === '$') || (c === '_') ||
+        (c === '\u200C') || (c === '\u200D') ||
+        unicode.ID_Continue.test(c)
+        )
+    },
+
+    isDigit (c) {
+        return typeof c === 'string' && /[0-9]/.test(c)
+    },
+
+    isHexDigit (c) {
+        return typeof c === 'string' && /[0-9A-Fa-f]/.test(c)
+    },
+}

adi-ui/.pnpm-store/v10/files/00/46b7e2d19fe0381f74f43589a9c95a325fd6d18d930c9309abff838dad378294771c21dbf5a03d5b7426197e8698f2d5d54131bf846794c914d8a35673ff9f

@@ -0,0 +1,16 @@
+'use strict'
+
+const u = require('universalify').fromCallback
+const jsonFile = require('./jsonfile')
+
+jsonFile.outputJson = u(require('./output-json'))
+jsonFile.outputJsonSync = require('./output-json-sync')
+// aliases
+jsonFile.outputJSON = jsonFile.outputJson
+jsonFile.outputJSONSync = jsonFile.outputJsonSync
+jsonFile.writeJSON = jsonFile.writeJson
+jsonFile.writeJSONSync = jsonFile.writeJsonSync
+jsonFile.readJSON = jsonFile.readJson
+jsonFile.readJSONSync = jsonFile.readJsonSync
+
+module.exports = jsonFile

adi-ui/.pnpm-store/v10/files/00/46da34334d62595ee9b5e3ff6c2893305344e79d440694300de955d7cc9d96dc9af726c70d9c8e7f95a1d74fba10584b75ccc6eac4413ca69c2bee7ead0ce5

@@ -0,0 +1 @@
+module.exports={A:{A:{"1":"A B","2":"K D E F oC"},B:{"1":"0 9 C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB"},C:{"1":"0 4 5 6 7 8 9 TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB OC yB PC zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q H R QC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB GC RC SC qC rC","2":"1 2 3 pC NC J RB K D E F A B C L M G N O P SB sC tC"},D:{"1":"0 1 2 3 4 5 6 7 8 9 J RB K D E F A B C L M G N O P SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB OC yB PC zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB GC RC SC"},E:{"1":"J RB K D E F A B C L M G uC TC vC wC xC yC UC HC IC zC 0C 1C VC WC JC 2C KC XC YC ZC aC bC 3C LC cC dC eC fC gC 4C MC hC iC jC kC lC 5C"},F:{"1":"0 1 2 3 4 5 6 7 8 F B C G N O P SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q H R QC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 6C 7C 8C 9C HC mC AD IC"},G:{"1":"E CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD TD UD VC WC JC VD KC XC YC ZC aC bC WD LC cC dC eC fC gC XD MC hC iC jC kC lC","2":"TC BD nC"},H:{"2":"YD"},I:{"1":"I nC dD eD","4":"NC J ZD aD bD cD"},J:{"1":"D A"},K:{"1":"A B C H HC mC IC"},L:{"1":"I"},M:{"1":"GC"},N:{"1":"A B"},O:{"1":"JC"},P:{"1":"1 2 3 4 5 6 7 8 J fD gD hD iD jD UC kD lD mD nD oD KC LC MC pD"},Q:{"1":"qD"},R:{"1":"rD"},S:{"1":"sD tD"}},B:1,C:"Range input type",D:true};

adi-ui/.pnpm-store/v10/files/00/4b60241f6f527747f2f52cb492319da80abe1da96f414ce473efde488a48a621793bc4d032d7457f164f74aad7f3bf5375861a27347a542aaf0747d6401d3c

@@ -0,0 +1,63 @@
+var apply = require('./_apply'),
+    arrayPush = require('./_arrayPush'),
+    baseRest = require('./_baseRest'),
+    castSlice = require('./_castSlice'),
+    toInteger = require('./toInteger');
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * Creates a function that invokes `func` with the `this` binding of the
+ * create function and an array of arguments much like
+ * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
+ *
+ * **Note:** This method is based on the
+ * [spread operator](https://mdn.io/spread_operator).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.2.0
+ * @category Function
+ * @param {Function} func The function to spread arguments over.
+ * @param {number} [start=0] The start position of the spread.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var say = _.spread(function(who, what) {
+ *   return who + ' says ' + what;
+ * });
+ *
+ * say(['fred', 'hello']);
+ * // => 'fred says hello'
+ *
+ * var numbers = Promise.all([
+ *   Promise.resolve(40),
+ *   Promise.resolve(36)
+ * ]);
+ *
+ * numbers.then(_.spread(function(x, y) {
+ *   return x + y;
+ * }));
+ * // => a Promise of 76
+ */
+function spread(func, start) {
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  start = start == null ? 0 : nativeMax(toInteger(start), 0);
+  return baseRest(function(args) {
+    var array = args[start],
+        otherArgs = castSlice(args, 0, start);
+
+    if (array) {
+      arrayPush(otherArgs, array);
+    }
+    return apply(func, this, otherArgs);
+  });
+}
+
+module.exports = spread;

adi-ui/.pnpm-store/v10/files/00/50321917ab027404d8728aa9c7eb84f65ec06c6f3fe5f6c5b26944895e4f21d8ba8eef3b8faf135bde7cc0c93553649c993d68beac437b9f8742f7a7baa38f

@@ -0,0 +1,25 @@
+/**
+ * Checks if `value` is `null` or `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
+ * @example
+ *
+ * _.isNil(null);
+ * // => true
+ *
+ * _.isNil(void 0);
+ * // => true
+ *
+ * _.isNil(NaN);
+ * // => false
+ */
+function isNil(value) {
+  return value == null;
+}
+
+export default isNil;

adi-ui/.pnpm-store/v10/files/00/51c244af82966105c487552104963ecb86508c9bee96408f2b0ead9e2e96797ae950fd93ace0588972fb2b37961078cc3064def2dd38ad2320f7716f0cf6be

@@ -0,0 +1 @@
+module.exports={A:{A:{"2":"K D E F A B oC"},B:{"1":"Q","2":"0 9 C L M G N O P H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB"},C:{"2":"0 1 2 3 4 5 6 7 8 9 pC NC J RB K D E F A B C L M G N O P SB TB PC zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q H R QC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB GC RC SC qC rC sC tC","66":"UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB OC yB"},D:{"1":"aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB OC yB PC zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q","2":"0 1 2 3 4 5 9 J RB K D E F A B C L M G N O P SB H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB GC RC SC","33":"6 7 8 TB UB VB WB XB YB ZB"},E:{"2":"J RB K D E F A B C L M G uC TC vC wC xC yC UC HC IC zC 0C 1C VC WC JC 2C KC XC YC ZC aC bC 3C LC cC dC eC fC gC 4C MC hC iC jC kC lC 5C"},F:{"1":"3 4 5 6 7 8 TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B","2":"0 F B C 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q H R QC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 6C 7C 8C 9C HC mC AD IC","33":"1 2 G N O P SB"},G:{"2":"E TC BD nC CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD TD UD VC WC JC VD KC XC YC ZC aC bC WD LC cC dC eC fC gC XD MC hC iC jC kC lC"},H:{"2":"YD"},I:{"2":"NC J I ZD aD bD cD nC","33":"dD eD"},J:{"2":"D A"},K:{"2":"A B C H HC mC IC"},L:{"2":"I"},M:{"2":"GC"},N:{"2":"A B"},O:{"2":"JC"},P:{"1":"fD gD hD iD jD UC kD lD","2":"1 2 3 4 5 6 7 8 mD nD oD KC LC MC pD","33":"J"},Q:{"1":"qD"},R:{"2":"rD"},S:{"1":"sD","2":"tD"}},B:7,C:"Shadow DOM (deprecated V0 spec)",D:true};

adi-ui/.pnpm-store/v10/files/00/560aac1ae7a88a8f331a38cee2923b8d906238e1dd78b288bb0fe1eaa674e8eff7bae1127d07466fdacf715957e6a4574e6b2c6b9015960f3ff8a1fac3a666

@@ -0,0 +1,99 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+import { extend } from 'zrender/lib/core/util.js';
+
+function normalize(a) {
+  if (!(a instanceof Array)) {
+    a = [a, a];
+  }
+
+  return a;
+}
+
+export default function graphEdgeVisual(ecModel) {
+  ecModel.eachSeriesByType('graph', function (seriesModel) {
+    var graph = seriesModel.getGraph();
+    var edgeData = seriesModel.getEdgeData();
+    var symbolType = normalize(seriesModel.get('edgeSymbol'));
+    var symbolSize = normalize(seriesModel.get('edgeSymbolSize')); // const colorQuery = ['lineStyle', 'color'] as const;
+    // const opacityQuery = ['lineStyle', 'opacity'] as const;
+
+    edgeData.setVisual('fromSymbol', symbolType && symbolType[0]);
+    edgeData.setVisual('toSymbol', symbolType && symbolType[1]);
+    edgeData.setVisual('fromSymbolSize', symbolSize && symbolSize[0]);
+    edgeData.setVisual('toSymbolSize', symbolSize && symbolSize[1]);
+    edgeData.setVisual('style', seriesModel.getModel('lineStyle').getLineStyle());
+    edgeData.each(function (idx) {
+      var itemModel = edgeData.getItemModel(idx);
+      var edge = graph.getEdgeByIndex(idx);
+      var symbolType = normalize(itemModel.getShallow('symbol', true));
+      var symbolSize = normalize(itemModel.getShallow('symbolSize', true)); // Edge visual must after node visual
+
+      var style = itemModel.getModel('lineStyle').getLineStyle();
+      var existsStyle = edgeData.ensureUniqueItemVisual(idx, 'style');
+      extend(existsStyle, style);
+
+      switch (existsStyle.stroke) {
+        case 'source':
+          {
+            var nodeStyle = edge.node1.getVisual('style');
+            existsStyle.stroke = nodeStyle && nodeStyle.fill;
+            break;
+          }
+
+        case 'target':
+          {
+            var nodeStyle = edge.node2.getVisual('style');
+            existsStyle.stroke = nodeStyle && nodeStyle.fill;
+            break;
+          }
+      }
+
+      symbolType[0] && edge.setVisual('fromSymbol', symbolType[0]);
+      symbolType[1] && edge.setVisual('toSymbol', symbolType[1]);
+      symbolSize[0] && edge.setVisual('fromSymbolSize', symbolSize[0]);
+      symbolSize[1] && edge.setVisual('toSymbolSize', symbolSize[1]);
+    });
+  });
+}

adi-ui/.pnpm-store/v10/files/00/5651b5c0e2d03519073bb8634f6a43325925dd99498ffd2cf77e6222bf7952de3d8faf35c89010be1df13d138998ad718e619fbbdc1ec885052717a07a0a2f

@@ -0,0 +1,6 @@
+'use strict';
+var defineWellKnownSymbol = require('../internals/well-known-symbol-define');
+
+// `Symbol.match` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.match
+defineWellKnownSymbol('match');

adi-ui/.pnpm-store/v10/files/00/56eba0a6267abfddc8af31402a7426b8ab3e98b26f15d318af60b94e7fa2241351e9029275c8299469cc1d91f20e3e8bff6e9d0670e4c10e5032d375718b3b

@@ -0,0 +1,44 @@
+'use strict';
+var global = require('../internals/global');
+var call = require('../internals/function-call');
+var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
+var lengthOfArrayLike = require('../internals/length-of-array-like');
+var toOffset = require('../internals/to-offset');
+var toIndexedObject = require('../internals/to-object');
+var fails = require('../internals/fails');
+
+var RangeError = global.RangeError;
+var Int8Array = global.Int8Array;
+var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
+var $set = Int8ArrayPrototype && Int8ArrayPrototype.set;
+var aTypedArray = ArrayBufferViewCore.aTypedArray;
+var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
+
+var WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS = !fails(function () {
+  // eslint-disable-next-line es/no-typed-arrays -- required for testing
+  var array = new Uint8ClampedArray(2);
+  call($set, array, { length: 1, 0: 3 }, 1);
+  return array[1] !== 3;
+});
+
+// https://bugs.chromium.org/p/v8/issues/detail?id=11294 and other
+var TO_OBJECT_BUG = WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS && ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS && fails(function () {
+  var array = new Int8Array(2);
+  array.set(1);
+  array.set('2', 1);
+  return array[0] !== 0 || array[1] !== 2;
+});
+
+// `%TypedArray%.prototype.set` method
+// https://tc39.es/ecma262/#sec-%typedarray%.prototype.set
+exportTypedArrayMethod('set', function set(arrayLike /* , offset */) {
+  aTypedArray(this);
+  var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1);
+  var src = toIndexedObject(arrayLike);
+  if (WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS) return call($set, this, src, offset);
+  var length = this.length;
+  var len = lengthOfArrayLike(src);
+  var index = 0;
+  if (len + offset > length) throw new RangeError('Wrong length');
+  while (index < len) this[offset + index] = src[index++];
+}, !WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS || TO_OBJECT_BUG);

adi-ui/.pnpm-store/v10/files/00/59e859b578350a4f315ca4e2a771dd60510b8d0be2419bf5b8405445c704ed8aa669338bda03868c3aeb9720c4c44e89256fafd7a68399202f2efdf402eacf-exec

@@ -0,0 +1,52 @@
+{
+  "name": "esrecurse",
+  "description": "ECMAScript AST recursive visitor",
+  "homepage": "https://github.com/estools/esrecurse",
+  "main": "esrecurse.js",
+  "version": "4.3.0",
+  "engines": {
+    "node": ">=4.0"
+  },
+  "maintainers": [
+    {
+      "name": "Yusuke Suzuki",
+      "email": "utatane.tea@gmail.com",
+      "web": "https://github.com/Constellation"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/estools/esrecurse.git"
+  },
+  "dependencies": {
+    "estraverse": "^5.2.0"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.24.1",
+    "babel-eslint": "^7.2.3",
+    "babel-preset-es2015": "^6.24.1",
+    "babel-register": "^6.24.1",
+    "chai": "^4.0.2",
+    "esprima": "^4.0.0",
+    "gulp": "^3.9.0",
+    "gulp-bump": "^2.7.0",
+    "gulp-eslint": "^4.0.0",
+    "gulp-filter": "^5.0.0",
+    "gulp-git": "^2.4.1",
+    "gulp-mocha": "^4.3.1",
+    "gulp-tag-version": "^1.2.1",
+    "jsdoc": "^3.3.0-alpha10",
+    "minimist": "^1.1.0"
+  },
+  "license": "BSD-2-Clause",
+  "scripts": {
+    "test": "gulp travis",
+    "unit-test": "gulp test",
+    "lint": "gulp lint"
+  },
+  "babel": {
+    "presets": [
+      "es2015"
+    ]
+  }
+}

adi-ui/.pnpm-store/v10/files/00/5dd085ca65bf9626fc58be1dd97c40d4b640022f402aa21414ea20276fb8be65e9c585d8119206188ef7ca7ea16d6da0e2912b20fd6cfa66446f6ee69bfa8a

@@ -0,0 +1,65 @@
+{
+  "name": "@achrinza/node-ipc",
+  "version": "9.2.2",
+  "description": "A nodejs module for local and remote Inter Process Communication (IPC), Neural Networking, and able to facilitate machine learning.",
+  "main": "node-ipc.js",
+  "directories": {
+    "example": "example"
+  },
+  "engines": {
+    "node": "8 || 10 || 12 || 14 || 16 || 17"
+  },
+  "dependencies": {
+    "event-pubsub": "4.3.0",
+    "js-message": "1.0.7",
+    "@node-ipc/js-queue": "2.0.3"
+  },
+  "devDependencies": {
+    "codacy-coverage": "2.0.0",
+    "istanbul": "0.4.1",
+    "jasmine": "2.4.1",
+    "lockfile-lint": "^4.7.4",
+    "node-cmd": "2.0.0"
+  },
+  "scripts": {
+    "test-windows": "istanbul cover -x **/spec/** -dir ./spec/coverage ./node_modules/jasmine/bin/jasmine.js",
+    "test": "istanbul cover -x **/spec/** -dir ./spec/coverage jasmine",
+    "cover": "istanbul cover -x **/spec/** -dir ./spec/coverage jasmine",
+    "coverup": "cat ./spec/coverage/lcov.info | codacy-coverage"
+  },
+  "pre-commit": [
+    "cover"
+  ],
+  "keywords": [
+    "IPC",
+    "Neural Networking",
+    "Machine Learning",
+    "inter",
+    "process",
+    "communication",
+    "unix",
+    "windows",
+    "win",
+    "socket",
+    "TCP",
+    "UDP",
+    "domain",
+    "sockets",
+    "threaded",
+    "communication",
+    "multi",
+    "process",
+    "shared",
+    "memory"
+  ],
+  "author": "Brandon Nozaki Miller",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/achrinza/node-ipc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/achrinza/node-ipc/issues"
+  },
+  "homepage": "https://github.com/achrinza/node-ipc"
+}

adi-ui/.pnpm-store/v10/files/00/5ed47ed7ce651c09df844dcaf7dfcdd27d39d58fbdaa538139924a4d8ff220dfdfa3404614393de131053687166727dd9e62b96161306bb2809eb96a93dc70

@@ -0,0 +1,86 @@
+module.exports = function normalize(path) {
+	var parts = path.split(/(\\+|\/+)/);
+	if(parts.length === 1)
+		return path;
+	var result = [];
+	var absolutePathStart = 0;
+	for(var i = 0, sep = false; i < parts.length; i++, sep = !sep) {
+		var part = parts[i];
+		if(i === 0 && /^([A-Z]:)?$/i.test(part)) {
+			result.push(part);
+			absolutePathStart = 2;
+		} else if(sep) {
+			result.push(part[0]);
+		} else if(part === "..") {
+			switch(result.length) {
+				case 0:
+					// i. e. ".." => ".."
+					// i. e. "../a/b/c" => "../a/b/c"
+					result.push(part);
+					break;
+				case 2:
+					// i. e. "a/.." => ""
+					// i. e. "/.." => "/"
+					// i. e. "C:\.." => "C:\"
+					// i. e. "a/../b/c" => "b/c"
+					// i. e. "/../b/c" => "/b/c"
+					// i. e. "C:\..\a\b\c" => "C:\a\b\c"
+					i++;
+					sep = !sep;
+					result.length = absolutePathStart;
+					break;
+				case 4:
+					// i. e. "a/b/.." => "a"
+					// i. e. "/a/.." => "/"
+					// i. e. "C:\a\.." => "C:\"
+					// i. e. "/a/../b/c" => "/b/c"
+					if(absolutePathStart === 0) {
+						result.length -= 3;
+					} else {
+						i++;
+						sep = !sep;
+						result.length = 2;
+					}
+					break;
+				default:
+					// i. e. "/a/b/.." => "/a"
+					// i. e. "/a/b/../c" => "/a/c"
+					result.length -= 3;
+					break;
+			}
+		} else if(part === ".") {
+			switch(result.length) {
+				case 0:
+					// i. e. "." => "."
+					// i. e. "./a/b/c" => "./a/b/c"
+					result.push(part);
+					break;
+				case 2:
+					// i. e. "a/." => "a"
+					// i. e. "/." => "/"
+					// i. e. "C:\." => "C:\"
+					// i. e. "C:\.\a\b\c" => "C:\a\b\c"
+					if(absolutePathStart === 0) {
+						result.length--;
+					} else {
+						i++;
+						sep = !sep;
+					}
+					break;
+				default:
+					// i. e. "a/b/." => "a/b"
+					// i. e. "/a/." => "/"
+					// i. e. "C:\a\." => "C:\"
+					// i. e. "a/./b/c" => "a/b/c"
+					// i. e. "/a/./b/c" => "/a/b/c"
+					result.length--;
+					break;
+			}
+		} else if(part) {
+			result.push(part);
+		}
+	}
+	if(result.length === 1 && /^[A-Za-z]:$/.test(result))
+		return result[0] + "\\";
+	return result.join("");
+};

adi-ui/.pnpm-store/v10/files/00/601ff40ae54e4aa2c30791a953fb342079060efb175837b9078e59bdf54da3c3bc89bc6749b5d8acfd7e701f438fcdf4314abc4d9e79d27a56abe913630a1b

@@ -0,0 +1,73 @@
+/*
+  IR_Black style (c) Vasily Mikhailitchenko <vaskas@programica.ru>
+*/
+
+.hljs {
+  display: block;
+  overflow-x: auto;
+  padding: 0.5em;
+  background: #000;
+  color: #f8f8f8;
+}
+
+.hljs-comment,
+.hljs-quote,
+.hljs-meta {
+  color: #7c7c7c;
+}
+
+.hljs-keyword,
+.hljs-selector-tag,
+.hljs-tag,
+.hljs-name {
+  color: #96cbfe;
+}
+
+.hljs-attribute,
+.hljs-selector-id {
+  color: #ffffb6;
+}
+
+.hljs-string,
+.hljs-selector-attr,
+.hljs-selector-pseudo,
+.hljs-addition {
+  color: #a8ff60;
+}
+
+.hljs-subst {
+  color: #daefa3;
+}
+
+.hljs-regexp,
+.hljs-link {
+  color: #e9c062;
+}
+
+.hljs-title,
+.hljs-section,
+.hljs-type,
+.hljs-doctag {
+  color: #ffffb6;
+}
+
+.hljs-symbol,
+.hljs-bullet,
+.hljs-variable,
+.hljs-template-variable,
+.hljs-literal {
+  color: #c6c5fe;
+}
+
+.hljs-number,
+.hljs-deletion {
+  color:#ff73fd;
+}
+
+.hljs-emphasis {
+  font-style: italic;
+}
+
+.hljs-strong {
+  font-weight: bold;
+}

adi-ui/.pnpm-store/v10/files/00/60f73be75fcdfafb9b5a37e9ac9ac092f99c0ed9475eca78cff8559b0b37af087bb27bc3b025b002fe61ba40bb626c554eeccacb872b3c66343f56c23f277f

@@ -0,0 +1,21 @@
+'use strict';
+
+var define = require('define-properties');
+var getPolyfill = require('./polyfill');
+
+module.exports = function shimGetPrototypeOf() {
+	define(
+		global,
+		{ Reflect: {} },
+		{ Reflect: function () { return typeof Reflect !== 'object' || !Reflect; } }
+	);
+
+	var polyfill = getPolyfill();
+	define(
+		Reflect,
+		{ getPrototypeOf: polyfill },
+		{ getPrototypeOf: function () { return Reflect.getPrototypeOf !== polyfill; } }
+	);
+
+	return polyfill;
+};

adi-ui/.pnpm-store/v10/files/00/61a8646b26d16deb6ed9705454917d48d7f784becdccf24aac2efce3e3c46b7b6fa74e6bb92c2e568c7ef217538b6bc865d518245bebeba92c47f43b0050fc

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+const which = require('../lib')
+const argv = process.argv.slice(2)
+
+const usage = (err) => {
+  if (err) {
+    console.error(`which: ${err}`)
+  }
+  console.error('usage: which [-as] program ...')
+  process.exit(1)
+}
+
+if (!argv.length) {
+  return usage()
+}
+
+let dashdash = false
+const [commands, flags] = argv.reduce((acc, arg) => {
+  if (dashdash || arg === '--') {
+    dashdash = true
+    return acc
+  }
+
+  if (!/^-/.test(arg)) {
+    acc[0].push(arg)
+    return acc
+  }
+
+  for (const flag of arg.slice(1).split('')) {
+    if (flag === 's') {
+      acc[1].silent = true
+    } else if (flag === 'a') {
+      acc[1].all = true
+    } else {
+      usage(`illegal option -- ${flag}`)
+    }
+  }
+
+  return acc
+}, [[], {}])
+
+for (const command of commands) {
+  try {
+    const res = which.sync(command, { all: flags.all })
+    if (!flags.silent) {
+      console.log([].concat(res).join('\n'))
+    }
+  } catch (err) {
+    process.exitCode = 1
+  }
+}

adi-ui/.pnpm-store/v10/files/00/62ba708ef3a89ce025b02cacffa2a9b6b3f5afed1a83b6885537d74e84ea7a2e4f9e2005eb923d863ff06206560d0912f6de71bb424df9bdb04649fccd9f12

@@ -0,0 +1,5 @@
+'use strict';
+
+// https://262.ecma-international.org/6.0/#sec-algorithm-conventions
+
+module.exports = require('math-intrinsics/min');

adi-ui/.pnpm-store/v10/files/00/640a253c1a24c85a4edad64e58b3dad97df5866f91215e1697b7e9b7b366615972c204658b29b74cd66406f256633464b0a0c8ad1999ee5142ce0e42d17345

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var pathUtils = require("../../utils/path");
+var patternUtils = require("../../utils/pattern");
+var EntryFilter = /** @class */ (function () {
+    function EntryFilter(options, micromatchOptions) {
+        this.options = options;
+        this.micromatchOptions = micromatchOptions;
+        this.index = new Map();
+    }
+    /**
+     * Returns filter for directories.
+     */
+    EntryFilter.prototype.getFilter = function (positive, negative) {
+        var _this = this;
+        var positiveRe = patternUtils.convertPatternsToRe(positive, this.micromatchOptions);
+        var negativeRe = patternUtils.convertPatternsToRe(negative, this.micromatchOptions);
+        return function (entry) { return _this.filter(entry, positiveRe, negativeRe); };
+    };
+    /**
+     * Returns true if entry must be added to result.
+     */
+    EntryFilter.prototype.filter = function (entry, positiveRe, negativeRe) {
+        // Exclude duplicate results
+        if (this.options.unique) {
+            if (this.isDuplicateEntry(entry)) {
+                return false;
+            }
+            this.createIndexRecord(entry);
+        }
+        // Filter files and directories by options
+        if (this.onlyFileFilter(entry) || this.onlyDirectoryFilter(entry)) {
+            return false;
+        }
+        if (this.isSkippedByAbsoluteNegativePatterns(entry, negativeRe)) {
+            return false;
+        }
+        return this.isMatchToPatterns(entry.path, positiveRe) && !this.isMatchToPatterns(entry.path, negativeRe);
+    };
+    /**
+     * Return true if the entry already has in the cross reader index.
+     */
+    EntryFilter.prototype.isDuplicateEntry = function (entry) {
+        return this.index.has(entry.path);
+    };
+    /**
+     * Create record in the cross reader index.
+     */
+    EntryFilter.prototype.createIndexRecord = function (entry) {
+        this.index.set(entry.path, undefined);
+    };
+    /**
+     * Returns true for non-files if the «onlyFiles» option is enabled.
+     */
+    EntryFilter.prototype.onlyFileFilter = function (entry) {
+        return this.options.onlyFiles && !entry.isFile();
+    };
+    /**
+     * Returns true for non-directories if the «onlyDirectories» option is enabled.
+     */
+    EntryFilter.prototype.onlyDirectoryFilter = function (entry) {
+        return this.options.onlyDirectories && !entry.isDirectory();
+    };
+    /**
+     * Return true when `absolute` option is enabled and matched to the negative patterns.
+     */
+    EntryFilter.prototype.isSkippedByAbsoluteNegativePatterns = function (entry, negativeRe) {
+        if (!this.options.absolute) {
+            return false;
+        }
+        var fullpath = pathUtils.makeAbsolute(this.options.cwd, entry.path);
+        return this.isMatchToPatterns(fullpath, negativeRe);
+    };
+    /**
+     * Return true when entry match to provided patterns.
+     *
+     * First, just trying to apply patterns to the path.
+     * Second, trying to apply patterns to the path with final slash (need to micromatch to support «directory/**» patterns).
+     */
+    EntryFilter.prototype.isMatchToPatterns = function (filepath, patternsRe) {
+        return patternUtils.matchAny(filepath, patternsRe) || patternUtils.matchAny(filepath + '/', patternsRe);
+    };
+    return EntryFilter;
+}());
+exports.default = EntryFilter;

adi-ui/.pnpm-store/v10/files/00/6468eef7e9abacd2a3a22ebc6454be65452a516c9aa80eee2a3632ad56ccdf61c22eef4d02d033d8e5eae5e1da6a8a3ffd0720b2fb728733a5cae91bf1c61d

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../../stable/instance/flat');
+
+module.exports = parent;

adi-ui/.pnpm-store/v10/files/00/64a06fd4aca7c7a55b947741197a7017261d81588085d21127024e22ebd2d09d2cf522b979b532663cae7b866f63ba3fb29b8ecfab959d67ee978ea3e61e85

@@ -0,0 +1 @@
+.el-skeleton__item{background:#f2f2f2;display:inline-block;height:16px;border-radius:4px;width:100%}.el-skeleton__circle{border-radius:50%;width:36px;height:36px;line-height:36px}.el-skeleton__circle--lg{width:40px;height:40px;line-height:40px}.el-skeleton__circle--md{width:28px;height:28px;line-height:28px}.el-skeleton__button{height:40px;width:64px;border-radius:4px}.el-skeleton__p{width:100%}.el-skeleton__p.is-last{width:61%}.el-skeleton__p.is-first{width:33%}.el-skeleton__text{width:100%;height:13px}.el-skeleton__caption{height:12px}.el-skeleton__h1{height:20px}.el-skeleton__h3{height:18px}.el-skeleton__h5{height:16px}.el-skeleton__image{width:unset;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-align:center;-ms-flex-align:center;align-items:center;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center;border-radius:0}.el-skeleton__image svg{fill:#DCDDE0;width:22%;height:22%}@-webkit-keyframes el-skeleton-loading{0%{background-position:100% 50%}100%{background-position:0 50%}}@keyframes el-skeleton-loading{0%{background-position:100% 50%}100%{background-position:0 50%}}.el-skeleton{width:100%}.el-skeleton__first-line,.el-skeleton__paragraph{height:16px;margin-top:16px;background:#f2f2f2}.el-skeleton.is-animated .el-skeleton__item{background:-webkit-gradient(linear,left top,right top,color-stop(25%,#f2f2f2),color-stop(37%,#e6e6e6),color-stop(63%,#f2f2f2));background:linear-gradient(90deg,#f2f2f2 25%,#e6e6e6 37%,#f2f2f2 63%);background-size:400% 100%;-webkit-animation:el-skeleton-loading 1.4s ease infinite;animation:el-skeleton-loading 1.4s ease infinite}

adi-ui/.pnpm-store/v10/files/00/6bcd45dfd9dea981808256aecc46e723892ce5a6ae833812f10dde6bb6007714bb73610fda2c1db5a0ec717a8401e940dbf23e7712dd919711dc0049817d38

@@ -0,0 +1,6 @@
+/* @flow */
+
+export { parseComponent } from 'sfc/parser'
+export { compile, compileToFunctions } from './compiler/index'
+export { ssrCompile, ssrCompileToFunctions } from './server/compiler'
+export { generateCodeFrame } from 'compiler/codeframe'

adi-ui/.pnpm-store/v10/files/00/702f787992c87e1aca69d77edbac22c0d48fcd985655f03ceb5bdb2753d68214611bc03545f6c2cc4de8a5f782a644c99e31163e02a94a45677dc3611b75f9

@@ -0,0 +1,263 @@
+var assert = require('assert')
+var util = require('util')
+
+var EventEmitter = require('events').EventEmitter
+var Buffer = require('buffer').Buffer
+
+var Queue = require('./queue')
+
+// Node.js version
+var match = /^v(\d+)\.(\d+)\./.exec(process.version)
+var version = match ? Number(match[1]) + Number('0.' + match[2]) : 11
+var onreadMode = version >= 11.1 ? 2 : 1
+var mode = 'modern'
+
+var setNRead
+if (onreadMode === 2) {
+  var sw = process.binding('stream_wrap')
+  setNRead = function (nread) {
+    sw.streamBaseState[sw.kReadBytesOrError] = nread
+  }
+}
+
+function Handle (stream, options) {
+  EventEmitter.call(this)
+
+  this._stream = stream
+  this._flowing = false
+  this._reading = false
+  this._options = options || {}
+
+  this.onread = null
+
+  // Pending requests
+  this.pending = new Queue()
+}
+util.inherits(Handle, EventEmitter)
+module.exports = Handle
+
+Handle.mode = mode
+
+Handle.create = function create (stream, options) {
+  return new Handle(stream, options)
+}
+
+Handle.prototype._onread = function _onread (nread, buffer) {
+  if (onreadMode === 1) {
+    this.onread(nread, buffer)
+  } else {
+    setNRead(nread)
+    this.onread(buffer)
+  }
+}
+
+Handle.prototype._queueReq = function _queueReq (type, req) {
+  return this.pending.append(type, req)
+}
+
+Handle.prototype._pendingList = function _pendingList () {
+  var list = []
+  while (!this.pending.isEmpty()) { list.push(this.pending.first().dequeue()) }
+  return list
+}
+
+Handle.prototype.setStream = function setStream (stream) {
+  assert(this._stream === null, 'Can\'t set stream two times')
+  this._stream = stream
+
+  this.emit('stream', stream)
+}
+
+Handle.prototype.readStart = function readStart () {
+  this._reading = true
+
+  if (!this._stream) {
+    this.once('stream', this.readStart)
+    return 0
+  }
+
+  if (!this._flowing) {
+    this._flowing = true
+    this._flow()
+  }
+
+  this._stream.resume()
+  return 0
+}
+
+Handle.prototype.readStop = function readStop () {
+  this._reading = false
+
+  if (!this._stream) {
+    this.once('stream', this.readStop)
+    return 0
+  }
+  this._stream.pause()
+  return 0
+}
+
+var uv = process.binding('uv')
+
+Handle.prototype._flow = function flow () {
+  var self = this
+  this._stream.on('data', function (chunk) {
+    self._onread(chunk.length, chunk)
+  })
+
+  this._stream.on('end', function () {
+    self._onread(uv.UV_EOF, Buffer.alloc(0))
+  })
+
+  this._stream.on('close', function () {
+    setImmediate(function () {
+      if (self._reading) {
+        self._onread(uv.UV_ECONNRESET, Buffer.alloc(0))
+      }
+    })
+  })
+}
+
+Handle.prototype._close = function _close () {
+  var list = this._pendingList()
+
+  var self = this
+  setImmediate(function () {
+    for (var i = 0; i < list.length; i++) {
+      var req = list[i]
+      req.oncomplete(uv.UV_ECANCELED, self, req)
+    }
+  })
+
+  this.readStop()
+}
+
+Handle.prototype.shutdown = function shutdown (req) {
+  var wrap = this._queueReq('shutdown', req)
+
+  if (!this._stream) {
+    this.once('stream', function () {
+      this._shutdown(wrap)
+    })
+    return 0
+  }
+
+  return this._shutdown(wrap)
+}
+
+Handle.prototype._shutdown = function _shutdown (wrap) {
+  var self = this
+  this._stream.end(function () {
+    var req = wrap.dequeue()
+    if (!req) { return }
+
+    req.oncomplete(0, self, req)
+  })
+  return 0
+}
+
+Handle.prototype.close = function close (callback) {
+  this._close()
+
+  if (!this._stream) {
+    this.once('stream', function () {
+      this.close(callback)
+    })
+    return 0
+  }
+
+  if (this._options.close) {
+    this._options.close(callback)
+  } else {
+    process.nextTick(callback)
+  }
+
+  return 0
+}
+
+Handle.prototype.writeEnc = function writeEnc (req, data, enc) {
+  var wrap = this._queueReq('write', req)
+
+  if (!this._stream) {
+    this.once('stream', function () {
+      this._writeEnc(wrap, req, data, enc)
+    })
+
+    return 0
+  }
+
+  return this._writeEnc(wrap, req, data, enc)
+}
+
+Handle.prototype._writeEnc = function _writeEnc (wrap, req, data, enc) {
+  var self = this
+
+  req.async = true
+  req.bytes = data.length
+
+  if (wrap.isEmpty()) {
+    return 0
+  }
+
+  this._stream.write(data, enc, function () {
+    var req = wrap.dequeue()
+    if (!req) { return }
+    req.oncomplete(0, self, req)
+  })
+
+  return 0
+}
+
+/**
+ * @param {WriteWrap} req
+ * @param {string[]} chunks
+ * @param {Boolean} allBuffers
+ */
+Handle.prototype.writev = function _writev (req, chunks, allBuffers) {
+  while (chunks.length > 0) {
+    this._stream.write(chunks.shift(), chunks.shift())
+  }
+  return 0
+}
+
+Handle.prototype.writeBuffer = function writeBuffer (req, data) {
+  return this.writeEnc(req, data, null)
+}
+
+Handle.prototype.writeAsciiString = function writeAsciiString (req, data) {
+  return this.writeEnc(req, data, 'ascii')
+}
+
+Handle.prototype.writeUtf8String = function writeUtf8String (req, data) {
+  return this.writeEnc(req, data, 'utf8')
+}
+
+Handle.prototype.writeUcs2String = function writeUcs2String (req, data) {
+  return this.writeEnc(req, data, 'ucs2')
+}
+
+Handle.prototype.writeBinaryString = function writeBinaryString (req, data) {
+  return this.writeEnc(req, data, 'binary')
+}
+
+Handle.prototype.writeLatin1String = function writeLatin1String (req, data) {
+  return this.writeEnc(req, data, 'binary')
+}
+
+// v0.8
+Handle.prototype.getsockname = function getsockname () {
+  if (this._options.getPeerName) {
+    return this._options.getPeerName()
+  }
+  return null
+}
+
+Handle.prototype.getpeername = function getpeername (out) {
+  var res = this.getsockname()
+  if (!res) { return -1 }
+
+  Object.keys(res).forEach(function (key) {
+    out[key] = res[key]
+  })
+
+  return 0
+}

adi-ui/.pnpm-store/v10/files/00/7157e5e7edd1f52f0003a4f72192b80c665298f15bdf2a3fe48f18d05e430f1ff00a3041b706db130b8409d27264f13d48c14dde492f20831580fa53486e5d

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../../stable/typed-array/find-index');
+
+module.exports = parent;

adi-ui/.pnpm-store/v10/files/00/72f6ccc341280c7e5496fb0bccd5e8b353be7f2380a6af2cd609002c737ab09858d769134fd5214109a25bdc198557c5d827fd44d50672ffb49f48c9cb8914

@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("rxjs-compat/operator/debounceTime"));
+//# sourceMappingURL=debounceTime.js.map

adi-ui/.pnpm-store/v10/files/00/7392a55d3158deefd9b3f592b499601d931d445d9acb20a0e5098cb3f04fcd5865ebca8da53e875b05924bac3ef91c2ee2b6fc597af503735d376ef1c5c0c0

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/dom/ajax';

adi-ui/.pnpm-store/v10/files/00/75166e08bfe20ac0d45dbed325e4cac488087387b14022d57f4af5268f28b8121bd350915f5d0250c4fd411a537c767b304251c04a1e9d1ebc51a969f8ad00

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../../stable/instance/reverse');
+
+module.exports = parent;

adi-ui/.pnpm-store/v10/files/00/77366667339ef0fe485e79e843052618262074b26ff78be01314fef04e1fed5579ad5b0c394ed19c39140e2b274704aab5e3578f5aff643c7fc995e83b7a44

@@ -0,0 +1,78 @@
+/*
+Description: Srcery dark color scheme for highlight.js
+Author: Chen Bin <chen.bin@gmail.com>
+Website: https://srcery-colors.github.io/
+Date: 2020-04-06
+*/
+
+.hljs {
+  display: block;
+  overflow-x: auto;
+  padding: 0.5em;
+  background: #1C1B19;
+  color: #FCE8C3;
+}
+
+.hljs-strong,
+.hljs-emphasis {
+  color: #918175;
+}
+
+.hljs-bullet,
+.hljs-quote,
+.hljs-link,
+.hljs-number,
+.hljs-regexp,
+.hljs-literal {
+  color: #FF5C8F;
+}
+
+.hljs-code,
+.hljs-selector-class {
+  color: #68A8E4
+}
+
+.hljs-emphasis {
+  font-style: italic;
+}
+
+.hljs-keyword,
+.hljs-selector-tag,
+.hljs-section,
+.hljs-attribute,
+.hljs-variable {
+  color: #EF2F27;
+}
+
+.hljs-name,
+.hljs-title {
+  color: #FBB829;
+}
+
+.hljs-type,
+.hljs-params {
+  color: #0AAEB3;
+}
+
+.hljs-string {
+  color: #98BC37;
+}
+
+.hljs-subst,
+.hljs-built_in,
+.hljs-builtin-name,
+.hljs-symbol,
+.hljs-selector-id,
+.hljs-selector-attr,
+.hljs-selector-pseudo,
+.hljs-template-tag,
+.hljs-template-variable,
+.hljs-addition {
+  color: #C07ABE;
+}
+
+.hljs-comment,
+.hljs-deletion,
+.hljs-meta {
+  color: #918175;
+}

adi-ui/.pnpm-store/v10/files/00/783ce68d26e8508ef044a24da12c7e63e598acb8da73820ec0759c65ae7c31deff6d5102e7e0202e696255dc15e1956303c506537f033cd732d37b2e607c6d-exec

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+/*
+  Copyright JS Foundation and other contributors, https://js.foundation/
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*jslint sloppy:true plusplus:true node:true rhino:true */
+/*global phantom:true */
+
+var fs, system, esprima, options, fnames, forceFile, count;
+
+if (typeof esprima === 'undefined') {
+    // PhantomJS can only require() relative files
+    if (typeof phantom === 'object') {
+        fs = require('fs');
+        system = require('system');
+        esprima = require('./esprima');
+    } else if (typeof require === 'function') {
+        fs = require('fs');
+        try {
+            esprima = require('esprima');
+        } catch (e) {
+            esprima = require('../');
+        }
+    } else if (typeof load === 'function') {
+        try {
+            load('esprima.js');
+        } catch (e) {
+            load('../esprima.js');
+        }
+    }
+}
+
+// Shims to Node.js objects when running under PhantomJS 1.7+.
+if (typeof phantom === 'object') {
+    fs.readFileSync = fs.read;
+    process = {
+        argv: [].slice.call(system.args),
+        exit: phantom.exit,
+        on: function (evt, callback) {
+            callback();
+        }
+    };
+    process.argv.unshift('phantomjs');
+}
+
+// Shims to Node.js objects when running under Rhino.
+if (typeof console === 'undefined' && typeof process === 'undefined') {
+    console = { log: print };
+    fs = { readFileSync: readFile };
+    process = {
+        argv: arguments,
+        exit: quit,
+        on: function (evt, callback) {
+            callback();
+        }
+    };
+    process.argv.unshift('esvalidate.js');
+    process.argv.unshift('rhino');
+}
+
+function showUsage() {
+    console.log('Usage:');
+    console.log('   esvalidate [options] [file.js...]');
+    console.log();
+    console.log('Available options:');
+    console.log();
+    console.log('  --format=type  Set the report format, plain (default) or junit');
+    console.log('  -v, --version  Print program version');
+    console.log();
+    process.exit(1);
+}
+
+options = {
+    format: 'plain'
+};
+
+fnames = [];
+
+process.argv.splice(2).forEach(function (entry) {
+
+    if (forceFile || entry === '-' || entry.slice(0, 1) !== '-') {
+        fnames.push(entry);
+    } else if (entry === '-h' || entry === '--help') {
+        showUsage();
+    } else if (entry === '-v' || entry === '--version') {
+        console.log('ECMAScript Validator (using Esprima version', esprima.version, ')');
+        console.log();
+        process.exit(0);
+    } else if (entry.slice(0, 9) === '--format=') {
+        options.format = entry.slice(9);
+        if (options.format !== 'plain' && options.format !== 'junit') {
+            console.log('Error: unknown report format ' + options.format + '.');
+            process.exit(1);
+        }
+    } else if (entry === '--') {
+        forceFile = true;
+    } else {
+        console.log('Error: unknown option ' + entry + '.');
+        process.exit(1);
+    }
+});
+
+if (fnames.length === 0) {
+    fnames.push('');
+}
+
+if (options.format === 'junit') {
+    console.log('<?xml version="1.0" encoding="UTF-8"?>');
+    console.log('<testsuites>');
+}
+
+count = 0;
+
+function run(fname, content) {
+    var timestamp, syntax, name;
+    try {
+        if (typeof content !== 'string') {
+            throw content;
+        }
+
+        if (content[0] === '#' && content[1] === '!') {
+            content = '//' + content.substr(2, content.length);
+        }
+
+        timestamp = Date.now();
+        syntax = esprima.parse(content, { tolerant: true });
+
+        if (options.format === 'junit') {
+
+            name = fname;
+            if (name.lastIndexOf('/') >= 0) {
+                name = name.slice(name.lastIndexOf('/') + 1);
+            }
+
+            console.log('<testsuite name="' + fname + '" errors="0" ' +
+                ' failures="' + syntax.errors.length + '" ' +
+                ' tests="' + syntax.errors.length + '" ' +
+                ' time="' + Math.round((Date.now() - timestamp) / 1000) +
+                '">');
+
+            syntax.errors.forEach(function (error) {
+                var msg = error.message;
+                msg = msg.replace(/^Line\ [0-9]*\:\ /, '');
+                console.log('  <testcase name="Line ' + error.lineNumber + ': ' + msg + '" ' +
+                    ' time="0">');
+                console.log('    <error type="SyntaxError" message="' + error.message + '">' +
+                    error.message + '(' + name + ':' + error.lineNumber + ')' +
+                    '</error>');
+                console.log('  </testcase>');
+            });
+
+            console.log('</testsuite>');
+
+        } else if (options.format === 'plain') {
+
+            syntax.errors.forEach(function (error) {
+                var msg = error.message;
+                msg = msg.replace(/^Line\ [0-9]*\:\ /, '');
+                msg = fname + ':' + error.lineNumber + ': ' + msg;
+                console.log(msg);
+                ++count;
+            });
+
+        }
+    } catch (e) {
+        ++count;
+        if (options.format === 'junit') {
+            console.log('<testsuite name="' + fname + '" errors="1" failures="0" tests="1" ' +
+                ' time="' + Math.round((Date.now() - timestamp) / 1000) + '">');
+            console.log(' <testcase name="' + e.message + '" ' + ' time="0">');
+            console.log(' <error type="ParseError" message="' + e.message + '">' +
+                e.message + '(' + fname + ((e.lineNumber) ? ':' + e.lineNumber : '') +
+                ')</error>');
+            console.log(' </testcase>');
+            console.log('</testsuite>');
+        } else {
+            console.log(fname + ':' + e.lineNumber + ': ' + e.message.replace(/^Line\ [0-9]*\:\ /, ''));
+        }
+    }
+}
+
+fnames.forEach(function (fname) {
+    var content = '';
+    try {
+        if (fname && (fname !== '-' || forceFile)) {
+            content = fs.readFileSync(fname, 'utf-8');
+        } else {
+            fname = '';
+            process.stdin.resume();
+            process.stdin.on('data', function(chunk) {
+                content += chunk;
+            });
+            process.stdin.on('end', function() {
+                run(fname, content);
+            });
+            return;
+        }
+    } catch (e) {
+        content = e;
+    }
+    run(fname, content);
+});
+
+process.on('exit', function () {
+    if (options.format === 'junit') {
+        console.log('</testsuites>');
+    }
+
+    if (count > 0) {
+        process.exit(1);
+    }
+
+    if (count === 0 && typeof phantom === 'object') {
+        process.exit(0);
+    }
+});

adi-ui/.pnpm-store/v10/files/00/78bb49595e8f8a2a5eac9afaf5ba8b5ad1fa0c16db76354f89efc34a57ede0a08381bea001a9075aaed8bb97a3cd502df0ccc302b6cd81ede7da155adb7f04

@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("rxjs-compat/operator/windowToggle"));
+//# sourceMappingURL=windowToggle.js.map

adi-ui/.pnpm-store/v10/files/00/7b1e08717cb4bd9065f161079270ce12fc61c351d15e550827432f13b6472a0ac0c5908489356734b501c980e407bfc627ac9ce2d4870449c0f7a27645fd78

@@ -0,0 +1,8 @@
+'use strict';
+require('../../modules/es6.promise');
+require('../../modules/es7.promise.try');
+var $Promise = require('../../modules/_core').Promise;
+var $try = $Promise['try'];
+module.exports = { 'try': function (callbackfn) {
+  return $try.call(typeof this === 'function' ? this : $Promise, callbackfn);
+} }['try'];

adi-ui/.pnpm-store/v10/files/00/7d66de6030d503168d54842b1ac441117afe716c296c9c606741181caa46471d9b61a6e8d89575d5bcd0f68e2ef03a80655b88633e56c74763a7ba7b50506f

@@ -0,0 +1 @@
+{"version":3,"file":"concatMap.js","sourceRoot":"","sources":["../../../../src/internal/operators/concatMap.ts"],"names":[],"mappings":";;;AAAA,uCAAsC;AAEtC,iDAAgD;AA2EhD,SAAgB,SAAS,CACvB,OAAuC,EACvC,cAA6G;IAE7G,OAAO,uBAAU,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,mBAAQ,CAAC,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,mBAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;AAClG,CAAC;AALD,8BAKC"}

adi-ui/.pnpm-store/v10/files/00/7f480541b9a166c3744f710c36597764cda5ff98de4960b043ecad50583826acf27b62ef8bd98e63353a10b7f56eb8770f8389cc59c5792afb5fa79cfac25b

@@ -0,0 +1,95 @@
+module.exports = function(hljs) {
+  var keywords = {
+    'builtin-name':
+      // Clojure keywords
+      'def defonce cond apply if-not if-let if not not= = < > <= >= == + / * - rem '+
+      'quot neg? pos? delay? symbol? keyword? true? false? integer? empty? coll? list? '+
+      'set? ifn? fn? associative? sequential? sorted? counted? reversible? number? decimal? '+
+      'class? distinct? isa? float? rational? reduced? ratio? odd? even? char? seq? vector? '+
+      'string? map? nil? contains? zero? instance? not-every? not-any? libspec? -> ->> .. . '+
+      'inc compare do dotimes mapcat take remove take-while drop letfn drop-last take-last '+
+      'drop-while while intern condp case reduced cycle split-at split-with repeat replicate '+
+      'iterate range merge zipmap declare line-seq sort comparator sort-by dorun doall nthnext '+
+      'nthrest partition eval doseq await await-for let agent atom send send-off release-pending-sends '+
+      'add-watch mapv filterv remove-watch agent-error restart-agent set-error-handler error-handler '+
+      'set-error-mode! error-mode shutdown-agents quote var fn loop recur throw try monitor-enter '+
+      'monitor-exit defmacro defn defn- macroexpand macroexpand-1 for dosync and or '+
+      'when when-not when-let comp juxt partial sequence memoize constantly complement identity assert '+
+      'peek pop doto proxy defstruct first rest cons defprotocol cast coll deftype defrecord last butlast '+
+      'sigs reify second ffirst fnext nfirst nnext defmulti defmethod meta with-meta ns in-ns create-ns import '+
+      'refer keys select-keys vals key val rseq name namespace promise into transient persistent! conj! '+
+      'assoc! dissoc! pop! disj! use class type num float double short byte boolean bigint biginteger '+
+      'bigdec print-method print-dup throw-if printf format load compile get-in update-in pr pr-on newline '+
+      'flush read slurp read-line subvec with-open memfn time re-find re-groups rand-int rand mod locking '+
+      'assert-valid-fdecl alias resolve ref deref refset swap! reset! set-validator! compare-and-set! alter-meta! '+
+      'reset-meta! commute get-validator alter ref-set ref-history-count ref-min-history ref-max-history ensure sync io! '+
+      'new next conj set! to-array future future-call into-array aset gen-class reduce map filter find empty '+
+      'hash-map hash-set sorted-map sorted-map-by sorted-set sorted-set-by vec vector seq flatten reverse assoc dissoc list '+
+      'disj get union difference intersection extend extend-type extend-protocol int nth delay count concat chunk chunk-buffer '+
+      'chunk-append chunk-first chunk-rest max min dec unchecked-inc-int unchecked-inc unchecked-dec-inc unchecked-dec unchecked-negate '+
+      'unchecked-add-int unchecked-add unchecked-subtract-int unchecked-subtract chunk-next chunk-cons chunked-seq? prn vary-meta '+
+      'lazy-seq spread list* str find-keyword keyword symbol gensym force rationalize'
+   };
+
+  var SYMBOLSTART = 'a-zA-Z_\\-!.?+*=<>&#\'';
+  var SYMBOL_RE = '[' + SYMBOLSTART + '][' + SYMBOLSTART + '0-9/;:]*';
+  var SIMPLE_NUMBER_RE = '[-+]?\\d+(\\.\\d+)?';
+
+  var SYMBOL = {
+    begin: SYMBOL_RE,
+    relevance: 0
+  };
+  var NUMBER = {
+    className: 'number', begin: SIMPLE_NUMBER_RE,
+    relevance: 0
+  };
+  var STRING = hljs.inherit(hljs.QUOTE_STRING_MODE, {illegal: null});
+  var COMMENT = hljs.COMMENT(
+    ';',
+    '$',
+    {
+      relevance: 0
+    }
+  );
+  var LITERAL = {
+    className: 'literal',
+    begin: /\b(true|false|nil)\b/
+  };
+  var COLLECTION = {
+    begin: '[\\[\\{]', end: '[\\]\\}]'
+  };
+  var HINT = {
+    className: 'comment',
+    begin: '\\^' + SYMBOL_RE
+  };
+  var HINT_COL = hljs.COMMENT('\\^\\{', '\\}');
+  var KEY = {
+    className: 'symbol',
+    begin: '[:]{1,2}' + SYMBOL_RE
+  };
+  var LIST = {
+    begin: '\\(', end: '\\)'
+  };
+  var BODY = {
+    endsWithParent: true,
+    relevance: 0
+  };
+  var NAME = {
+    keywords: keywords,
+    lexemes: SYMBOL_RE,
+    className: 'name', begin: SYMBOL_RE,
+    starts: BODY
+  };
+  var DEFAULT_CONTAINS = [LIST, STRING, HINT, HINT_COL, COMMENT, KEY, COLLECTION, NUMBER, LITERAL, SYMBOL];
+
+  LIST.contains = [hljs.COMMENT('comment', ''), NAME, BODY];
+  BODY.contains = DEFAULT_CONTAINS;
+  COLLECTION.contains = DEFAULT_CONTAINS;
+  HINT_COL.contains = [COLLECTION];
+
+  return {
+    aliases: ['clj'],
+    illegal: /\S/,
+    contains: [LIST, STRING, HINT, HINT_COL, COMMENT, KEY, COLLECTION, NUMBER, LITERAL]
+  }
+};

adi-ui/.pnpm-store/v10/files/00/8079bcf04ea1d216c1298c6f10816d6a8425bb85503d7d7222c26a0b206abbbe9d8d0db6ce6e7cc7568b13088adc809e7ab1ce54f43806fc59314e7edda1cf

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListrTaskState = void 0;
+/** Available task states. */
+var ListrTaskState;
+(function (ListrTaskState) {
+    ListrTaskState["PENDING"] = "PENDING";
+    ListrTaskState["COMPLETED"] = "COMPLETED";
+    ListrTaskState["FAILED"] = "FAILED";
+    ListrTaskState["SKIPPED"] = "SKIPPED";
+    ListrTaskState["ROLLING_BACK"] = "ROLLING_BACK";
+    ListrTaskState["ROLLED_BACK"] = "ROLLED_BACK";
+    ListrTaskState["RETRY"] = "RETRY";
+})(ListrTaskState = exports.ListrTaskState || (exports.ListrTaskState = {}));

adi-ui/.pnpm-store/v10/files/00/879645d028f36f1a1eeed52e47ad8e1c8a689dccf2b3cfe642d26d40735ffe59a624974e85a52c85fd4debf88392da9809b1cfd4eaf96e1db9234dc8c29a90

@@ -0,0 +1,7 @@
+'use strict';
+const path = require('path');
+const binaryExtensions = require('binary-extensions');
+
+const extensions = new Set(binaryExtensions);
+
+module.exports = filePath => extensions.has(path.extname(filePath).slice(1).toLowerCase());

adi-ui/.pnpm-store/v10/files/00/89098392754d2d4ecfbadfdd1197680b59753c55a88d7137ccdcb80ce4a6ed1f9238fae98f4d1488273d4615bb77e333f32138810f46b558f46591ff373b5e

@@ -0,0 +1,11 @@
+/**
+ * @author Yosuke Ota
+ */
+'use strict'
+
+const { wrapCoreRule } = require('../utils')
+
+// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
+module.exports = wrapCoreRule('func-call-spacing', {
+  skipDynamicArguments: true
+})

adi-ui/.pnpm-store/v10/files/00/8fed940668dc88775ca95ddc7aec398d662f0d371091aad1b1c113872355a78e0ecc6dc5fc0cfd2190e3c1f4a9ec7628eacb81ea5fb29ec17575f88dd46e18

@@ -0,0 +1,5 @@
+'use strict'
+
+module.exports.isClean = Symbol('isClean')
+
+module.exports.my = Symbol('my')

adi-ui/.pnpm-store/v10/files/00/91832f631c2c806afe250ffaf3e02e02f76290e36c46eee3d5da2b1ef356ed062c743d4a16a61c5b3fd585ef5a281dccc9b72c0abefef6935928134fef848d

@@ -0,0 +1 @@
+{"version":3,"file":"windowCount.js","sources":["../../src/add/operator/windowCount.ts"],"names":[],"mappings":";;AAAA,gDAA8C"}

adi-ui/.pnpm-store/v10/files/00/92a757da4dd0223e93fd9b514e058eb0d4523e7c1475eaad8498832fa16230b0f8b2a61c50e46318b05eedc1cde0ea264682f53f53b313b55603aa1ad075be

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("rxjs-compat/add/observable/merge");
+//# sourceMappingURL=merge.js.map

adi-ui/.pnpm-store/v10/files/00/92f1e0413e4ffdf7e9fcbde9c1865b465aca44ef07f49c57f356c72efac1757c17208d2f51279bc2af7e947ef365cda1c8795d25838273d807f8d9ff486d7f

@@ -0,0 +1,9 @@
+module.exports = {
+  y: 1 << 0,
+  n: 1 << 1,
+  a: 1 << 2,
+  p: 1 << 3,
+  u: 1 << 4,
+  x: 1 << 5,
+  d: 1 << 6
+}

adi-ui/.pnpm-store/v10/files/00/932fd4cb2eab07bf4d637a2fe1d74fb02871e7881542a01dfeaaf0b7fc571a72b2ef987b7845cf23e0e1e6761657c7f35f0d9a05d867e34a35b5a098a7f9c2

@@ -0,0 +1,89 @@
+{
+    // JSHint Default Configuration File (as on JSHint website)
+    // See http://jshint.com/docs/ for more details
+
+    "maxerr"        : 50,       // {int} Maximum error before stopping
+
+    // Enforcing
+    "bitwise"       : false,     // true: Prohibit bitwise operators (&, |, ^, etc.)
+    "camelcase"     : false,     // true: Identifiers must be in camelCase
+    "curly"         : false,     // true: Require {} for every new block or scope
+    "eqeqeq"        : true,     // true: Require triple equals (===) for comparison
+    "forin"         : true,     // true: Require filtering for..in loops with obj.hasOwnProperty()
+    "freeze"        : true,     // true: prohibits overwriting prototypes of native objects such as Array, Date etc.
+    "immed"         : false,    // true: Require immediate invocations to be wrapped in parens e.g. `(function () { } ());`
+    "indent"        : 2,        // {int} Number of spaces to use for indentation
+    "latedef"       : true,     // true: Require variables/functions to be defined before being used
+    "newcap"        : true,     // true: Require capitalization of all constructor functions e.g. `new F()`
+    "noarg"         : true,     // true: Prohibit use of `arguments.caller` and `arguments.callee`
+    "noempty"       : false,    // true: Prohibit use of empty blocks
+    "nonbsp"        : true,     // true: Prohibit "non-breaking whitespace" characters.
+    "nonew"         : false,    // true: Prohibit use of constructors for side-effects (without assignment)
+    "plusplus"      : false,    // true: Prohibit use of `++` & `--`
+    "quotmark"      : "single", // Quotation mark consistency:
+                                //   false    : do nothing (default)
+                                //   true     : ensure whatever is used is consistent
+                                //   "single" : require single quotes
+                                //   "double" : require double quotes
+    "undef"         : true,     // true: Require all non-global variables to be declared (prevents global leaks)
+    "unused"        : true,     // true: Require all defined variables be used
+    "strict"        : true,     // true: Requires all functions run in ES5 Strict Mode
+    "maxparams"     : false,    // {int} Max number of formal params allowed per function
+    "maxdepth"      : 3,        // {int} Max depth of nested blocks (within functions)
+    "maxstatements" : false,    // {int} Max number statements per function
+    "maxcomplexity" : false,    // {int} Max cyclomatic complexity per function
+    "maxlen"        : false,    // {int} Max number of characters per line
+
+    // Relaxing
+    "asi"           : false,     // true: Tolerate Automatic Semicolon Insertion (no semicolons)
+    "boss"          : false,     // true: Tolerate assignments where comparisons would be expected
+    "debug"         : false,     // true: Allow debugger statements e.g. browser breakpoints.
+    "eqnull"        : false,     // true: Tolerate use of `== null`
+    "es5"           : false,     // true: Allow ES5 syntax (ex: getters and setters)
+    "esnext"        : false,     // true: Allow ES.next (ES6) syntax (ex: `const`)
+    "moz"           : false,     // true: Allow Mozilla specific syntax (extends and overrides esnext features)
+                                 // (ex: `for each`, multiple try/catch, function expression…)
+    "evil"          : false,     // true: Tolerate use of `eval` and `new Function()`
+    "expr"          : false,     // true: Tolerate `ExpressionStatement` as Programs
+    "funcscope"     : false,     // true: Tolerate defining variables inside control statements
+    "globalstrict"  : false,     // true: Allow global "use strict" (also enables 'strict')
+    "iterator"      : false,     // true: Tolerate using the `__iterator__` property
+    "lastsemic"     : false,     // true: Tolerate omitting a semicolon for the last statement of a 1-line block
+    "laxbreak"      : false,     // true: Tolerate possibly unsafe line breakings
+    "laxcomma"      : false,     // true: Tolerate comma-first style coding
+    "loopfunc"      : false,     // true: Tolerate functions being defined in loops
+    "multistr"      : false,     // true: Tolerate multi-line strings
+    "noyield"       : false,     // true: Tolerate generator functions with no yield statement in them.
+    "notypeof"      : false,     // true: Tolerate invalid typeof operator values
+    "proto"         : false,     // true: Tolerate using the `__proto__` property
+    "scripturl"     : false,     // true: Tolerate script-targeted URLs
+    "shadow"        : true,      // true: Allows re-define variables later in code e.g. `var x=1; x=2;`
+    "sub"           : false,     // true: Tolerate using `[]` notation when it can still be expressed in dot notation
+    "supernew"      : false,     // true: Tolerate `new function () { ... };` and `new Object;`
+    "validthis"     : false,     // true: Tolerate using this in a non-constructor function
+
+    // Environments
+    "browser"       : true,     // Web Browser (window, document, etc)
+    "browserify"    : true,     // Browserify (node.js code in the browser)
+    "couch"         : false,    // CouchDB
+    "devel"         : true,     // Development/debugging (alert, confirm, etc)
+    "dojo"          : false,    // Dojo Toolkit
+    "jasmine"       : false,    // Jasmine
+    "jquery"        : false,    // jQuery
+    "mocha"         : true,     // Mocha
+    "mootools"      : false,    // MooTools
+    "node"          : true,     // Node.js
+    "nonstandard"   : false,    // Widely adopted globals (escape, unescape, etc)
+    "prototypejs"   : false,    // Prototype and Scriptaculous
+    "qunit"         : false,    // QUnit
+    "rhino"         : false,    // Rhino
+    "shelljs"       : false,    // ShellJS
+    "worker"        : false,    // Web Workers
+    "wsh"           : false,    // Windows Scripting Host
+    "yui"           : false,    // Yahoo User Interface
+
+    // Custom Globals
+    "globals"       : {
+        "module": true
+    }        // additional predefined global variables
+}

adi-ui/.pnpm-store/v10/files/00/9530fc7b936783b8c08f83efc065b4b49b6eba10ec493a5725527d98b889a19ef0e98ae732d3812967d9bd31b3d1f062577b260945d9363c34c5c0ffa4a61d

@@ -0,0 +1,34 @@
+var defer = require('./defer.js');
+
+// API
+module.exports = async;
+
+/**
+ * Runs provided callback asynchronously
+ * even if callback itself is not
+ *
+ * @param   {function} callback - callback to invoke
+ * @returns {function} - augmented callback
+ */
+function async(callback)
+{
+  var isAsync = false;
+
+  // check if async happened
+  defer(function() { isAsync = true; });
+
+  return function async_callback(err, result)
+  {
+    if (isAsync)
+    {
+      callback(err, result);
+    }
+    else
+    {
+      defer(function nextTick_callback()
+      {
+        callback(err, result);
+      });
+    }
+  };
+}

adi-ui/.pnpm-store/v10/files/00/9634fdfc86e30467a288813518be0d95b4fa1ce6f6bc0a1f9c92a7f5b3fe91f59648db5072fdf5d392b4600128fd98e5805fe534dd02b9dbaacd6bfea433bd

@@ -0,0 +1,4 @@
+'use strict';
+var parent = require('../../es/regexp/split');
+
+module.exports = parent;

adi-ui/.pnpm-store/v10/files/00/96fb7d66b8856e141dc755c13fa5c941da09fbedd622d6b7aa2e56547712ed35ca1912c244c031fe2b2e619087b9a5dc5d5d6eb4df9679f1731aa42d54ca35

@@ -0,0 +1,92 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var Get = require('es-abstract/2024/Get');
+var GetValueFromBuffer = require('es-abstract/2024/GetValueFromBuffer');
+var IsDetachedBuffer = require('es-abstract/2024/IsDetachedBuffer');
+var max = require('math-intrinsics/max');
+var min = require('math-intrinsics/min');
+var Set = require('es-abstract/2024/Set');
+var SetValueInBuffer = require('es-abstract/2024/SetValueInBuffer');
+var ToIntegerOrInfinity = require('es-abstract/2024/ToIntegerOrInfinity');
+var ToString = require('es-abstract/2024/ToString');
+var TypedArrayElementSize = require('es-abstract/2024/TypedArrayElementSize');
+var TypedArrayElementType = require('es-abstract/2024/TypedArrayElementType');
+var TypedArraySpeciesCreate = require('es-abstract/2024/TypedArraySpeciesCreate');
+var ValidateTypedArray = require('es-abstract/2024/ValidateTypedArray');
+
+var typedArrayBuffer = require('typed-array-buffer');
+var typedArrayByteOffset = require('typed-array-byte-offset');
+
+// https://tc39.es/ecma262/#sec-%typedarray%.prototype.slice
+
+module.exports = function slice(start, end) {
+	var O = this; // step 1
+
+	ValidateTypedArray(O, 'SEQ-CST'); // step 2
+
+	// 3. Let len be O.[[ArrayLength]].
+	var len = O.length; // steps 3
+
+	var relativeStart = ToIntegerOrInfinity(start); // step 4
+
+	var k;
+	if (relativeStart === -Infinity) {
+		k = 0; // step 5
+	} else if (relativeStart < 0) {
+		k = max(len + relativeStart, 0); // step 6
+	} else {
+		k = min(relativeStart, len); // step 7
+	}
+
+	var relativeEnd = typeof end === 'undefined' ? len : ToIntegerOrInfinity(end); // step 8
+
+	var final;
+	if (relativeEnd === -Infinity) {
+		final = 0; // step 9
+	} else if (relativeEnd < 0) {
+		final = max(len + relativeEnd, 0); // step 10
+	} else {
+		final = min(relativeEnd, len); // step 11
+	}
+
+	var count = max(final - k, 0); // step 12
+
+	var A = TypedArraySpeciesCreate(O, [count]); // step 13
+
+	if (count > 0) { // step 14
+		if (IsDetachedBuffer(typedArrayBuffer(O))) {
+			throw new $TypeError('Cannot use a Typed Array with an underlying ArrayBuffer that is detached'); // step 14.a
+		}
+		var srcType = TypedArrayElementType(O); // step 14.b
+		var targetType = TypedArrayElementType(A); // step 14.c
+		if (srcType === targetType) { // step 14.d
+			//  1. NOTE: The transfer must be performed in a manner that preserves the bit-level encoding of the source data.
+			var srcBuffer = typedArrayBuffer(O); // step 14.d.ii
+			var targetBuffer = typedArrayBuffer(A); // step 14.d.iii
+			var elementSize = TypedArrayElementSize(O); // step 14.d.iv
+			var srcByteOffset = typedArrayByteOffset(O); // step 14.d.v
+			var srcByteIndex = (k * elementSize) + srcByteOffset; // step 14.d.vi
+			var targetByteIndex = typedArrayByteOffset(A); // step 14.d.vii
+			var limit = targetByteIndex + (count * elementSize); // step 14.d.viii
+			while (targetByteIndex < limit) { // step 14.d.ix
+				var value = GetValueFromBuffer(srcBuffer, srcByteIndex, 'UINT8', true, 'UNORDERED'); // step 14.d.ix.1
+				SetValueInBuffer(targetBuffer, targetByteIndex, 'UINT8', value, true, 'UNORDERED'); // step 14.d.ix.2
+				srcByteIndex += 1; // step 14.d.ix.3
+				targetByteIndex += 1; // step 14.d.ix.4
+			}
+		} else { // step 14.e
+			var n = 0; // step 14.e.i
+			while (k < final) { // step 14.e.ii
+				var Pk = ToString(k); // step 14.e.ii.1
+				var kValue = Get(O, Pk); // step 14.e.ii.2
+				Set(A, ToString(n), kValue, true); // step 14.e.ii.3
+				k += 1; // step 14.e.ii.4
+				n += 1; // step 14.e.ii.5
+			}
+		}
+	}
+
+	return A; // step 15
+};

adi-ui/.pnpm-store/v10/files/00/9906d5e60fc990086c7b100e08a7c756c9713309cbc060469356ef53fbf0733484899a87a2e29b80ac79a4f74e4e22f30d6e0b39ab6e3307e6225446157882

@@ -0,0 +1 @@
+module.exports={A:{A:{"2":"K D E F A B oC"},B:{"1":"0 9 Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB","2":"C L M G N O P"},C:{"1":"0 9 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q H R QC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB GC RC SC qC rC","2":"1 2 3 4 5 6 7 8 pC NC J RB K D E F A B C L M G N O P SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB sC tC","132":"yB PC zB","450":"qB rB sB tB uB vB wB xB OC"},D:{"1":"0 9 7B 8B 9B AC BC CC DC EC FC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB I QB GC RC SC","2":"1 2 3 4 5 6 7 8 J RB K D E F A B C L M G N O P SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB","706":"tB uB vB wB xB OC yB PC zB 0B 1B 2B 3B 4B 5B 6B"},E:{"1":"M G 0C 1C VC WC JC 2C KC XC YC ZC aC bC 3C LC cC dC eC fC gC 4C MC hC iC jC kC lC 5C","2":"J RB K D E F A B C uC TC vC wC xC yC UC HC","1028":"L IC zC"},F:{"1":"0 wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC Q H R QC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z","2":"1 2 3 4 5 6 7 8 F B C G N O P SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB 6C 7C 8C 9C HC mC AD IC","706":"tB uB vB"},G:{"1":"ND OD PD QD RD SD TD UD VC WC JC VD KC XC YC ZC aC bC WD LC cC dC eC fC gC XD MC hC iC jC kC lC","2":"E TC BD nC CD DD ED FD GD HD ID JD KD LD MD"},H:{"2":"YD"},I:{"1":"I","2":"NC J ZD aD bD cD nC dD eD"},J:{"2":"D A"},K:{"1":"H","2":"A B C HC mC IC"},L:{"1":"I"},M:{"1":"GC"},N:{"2":"A B"},O:{"1":"JC"},P:{"1":"1 2 3 4 5 6 7 8 UC kD lD mD nD oD KC LC MC pD","2":"J fD gD hD iD jD"},Q:{"1":"qD"},R:{"1":"rD"},S:{"1":"tD","2":"sD"}},B:6,C:"TLS 1.3",D:true};

adi-ui/.pnpm-store/v10/files/00/990c5a374487d88d74b03e2efe6502ea877bd1af377ab23b6caaa35668492ce518516d52db695b09add01ba338db48c0b3886ed1c33fa1ab697569b5ba4f9c

@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("rxjs-compat/operator/delay"));
+//# sourceMappingURL=delay.js.map

adi-ui/.pnpm-store/v10/files/00/9c7dc1c3a0148f161f1eb6d20141b7bfbed1cd7bcf0664a815c815f3bf1078f251315d2e11f254ef0aed11fa9991ceac86e7a2344dc78e9c9567ad49821deb

@@ -0,0 +1,25 @@
+'use strict';
+
+var crypto = require('crypto');
+
+function md5(bytes) {
+  if (typeof Buffer.from === 'function') {
+    // Modern Buffer API
+    if (Array.isArray(bytes)) {
+      bytes = Buffer.from(bytes);
+    } else if (typeof bytes === 'string') {
+      bytes = Buffer.from(bytes, 'utf8');
+    }
+  } else {
+    // Pre-v4 Buffer API
+    if (Array.isArray(bytes)) {
+      bytes = new Buffer(bytes);
+    } else if (typeof bytes === 'string') {
+      bytes = new Buffer(bytes, 'utf8');
+    }
+  }
+
+  return crypto.createHash('md5').update(bytes).digest();
+}
+
+module.exports = md5;

adi-ui/.pnpm-store/v10/files/00/9d25a1f742fad3db2e34ac334149602a56ae56d38a168492df09feecb0ede991a821d547400c82703e2f039a4e840881c9dc855a72166b0458012f7dbcb9fd

@@ -0,0 +1 @@
+{"version":3,"file":"merge.js","sources":["../../../src/internal/observable/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAqHxC,MAAM,UAAU,KAAK,CAAO,GAAG,WAAiE;IAC/F,IAAI,UAAU,GAAG,MAAM,CAAC,iBAAiB,CAAC;IAC1C,IAAI,SAAS,GAAkB,IAAI,CAAC;IACnC,IAAI,IAAI,GAAQ,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACpD,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE;QACrB,SAAS,GAAkB,WAAW,CAAC,GAAG,EAAE,CAAC;QAC7C,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,QAAQ,EAAE;YACrF,UAAU,GAAW,WAAW,CAAC,GAAG,EAAE,CAAC;SACxC;KACF;SAAM,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QACnC,UAAU,GAAW,WAAW,CAAC,GAAG,EAAE,CAAC;KACxC;IAED,IAAI,SAAS,KAAK,IAAI,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,YAAY,UAAU,EAAE;QAC1F,OAAsB,WAAW,CAAC,CAAC,CAAC,CAAC;KACtC;IAED,OAAO,QAAQ,CAAI,UAAU,CAAC,CAAC,SAAS,CAAM,WAAW,EAAE,SAAS,CAAC,CAAC,CAAC;AACzE,CAAC"}

adi-ui/.pnpm-store/v10/files/00/9edf38b50a3a17d0f6d9494283b043ffbda2d72fb7bcdd04ee2624c0631bfb2b0cf00fd1a40f69a8a4e89dfeed877b3db4314f86c86ec240cd596c07a3b0fd

@@ -0,0 +1,49 @@
+/*
+Language: RenderMan RSL
+Author: Konstantin Evdokimenko <qewerty@gmail.com>
+Contributors: Shuen-Huei Guan <drake.guan@gmail.com>
+Website: https://renderman.pixar.com/resources/RenderMan_20/shadingLanguage.html
+Category: graphics
+*/
+
+function rsl(hljs) {
+  return {
+    name: 'RenderMan RSL',
+    keywords: {
+      keyword:
+        'float color point normal vector matrix while for if do return else break extern continue',
+      built_in:
+        'abs acos ambient area asin atan atmosphere attribute calculatenormal ceil cellnoise ' +
+        'clamp comp concat cos degrees depth Deriv diffuse distance Du Dv environment exp ' +
+        'faceforward filterstep floor format fresnel incident length lightsource log match ' +
+        'max min mod noise normalize ntransform opposite option phong pnoise pow printf ' +
+        'ptlined radians random reflect refract renderinfo round setcomp setxcomp setycomp ' +
+        'setzcomp shadow sign sin smoothstep specular specularbrdf spline sqrt step tan ' +
+        'texture textureinfo trace transform vtransform xcomp ycomp zcomp'
+    },
+    illegal: '</',
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.APOS_STRING_MODE,
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'meta',
+        begin: '#',
+        end: '$'
+      },
+      {
+        className: 'class',
+        beginKeywords: 'surface displacement light volume imager',
+        end: '\\('
+      },
+      {
+        beginKeywords: 'illuminate illuminance gather',
+        end: '\\('
+      }
+    ]
+  };
+}
+
+module.exports = rsl;

adi-ui/.pnpm-store/v10/files/00/9fb06a5fc4d1e6af87eb7f49e38a6a09a5ab71f9add894331b6f087f53adf2b3be80cff8e71b92e2826b7b0b89b40dd0efcddbade555737e8dcdbb2f87ece4

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [ljharb]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: npm/which-boxed-primitive
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

adi-ui/.pnpm-store/v10/files/00/a10e21c64632aaa84ecec480cc288098a41dceb21d9500d9c0b020d176481d9a8e5ea6f99405ce23e27d2a6eb217d8b85f81859599bf5a0ad3c28b225be395

@@ -0,0 +1,258 @@
+/**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function source(re) {
+  if (!re) return null;
+  if (typeof re === "string") return re;
+
+  return re.source;
+}
+
+/**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+function concat(...args) {
+  const joined = args.map((x) => source(x)).join("");
+  return joined;
+}
+
+/*
+Language: Markdown
+Requires: xml.js
+Author: John Crepezzi <john.crepezzi@gmail.com>
+Website: https://daringfireball.net/projects/markdown/
+Category: common, markup
+*/
+
+function markdown(hljs) {
+  const INLINE_HTML = {
+    begin: /<\/?[A-Za-z_]/,
+    end: '>',
+    subLanguage: 'xml',
+    relevance: 0
+  };
+  const HORIZONTAL_RULE = {
+    begin: '^[-\\*]{3,}',
+    end: '$'
+  };
+  const CODE = {
+    className: 'code',
+    variants: [
+      // TODO: fix to allow these to work with sublanguage also
+      {
+        begin: '(`{3,})[^`](.|\\n)*?\\1`*[ ]*'
+      },
+      {
+        begin: '(~{3,})[^~](.|\\n)*?\\1~*[ ]*'
+      },
+      // needed to allow markdown as a sublanguage to work
+      {
+        begin: '```',
+        end: '```+[ ]*$'
+      },
+      {
+        begin: '~~~',
+        end: '~~~+[ ]*$'
+      },
+      {
+        begin: '`.+?`'
+      },
+      {
+        begin: '(?=^( {4}|\\t))',
+        // use contains to gobble up multiple lines to allow the block to be whatever size
+        // but only have a single open/close tag vs one per line
+        contains: [
+          {
+            begin: '^( {4}|\\t)',
+            end: '(\\n)$'
+          }
+        ],
+        relevance: 0
+      }
+    ]
+  };
+  const LIST = {
+    className: 'bullet',
+    begin: '^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)',
+    end: '\\s+',
+    excludeEnd: true
+  };
+  const LINK_REFERENCE = {
+    begin: /^\[[^\n]+\]:/,
+    returnBegin: true,
+    contains: [
+      {
+        className: 'symbol',
+        begin: /\[/,
+        end: /\]/,
+        excludeBegin: true,
+        excludeEnd: true
+      },
+      {
+        className: 'link',
+        begin: /:\s*/,
+        end: /$/,
+        excludeBegin: true
+      }
+    ]
+  };
+  const URL_SCHEME = /[A-Za-z][A-Za-z0-9+.-]*/;
+  const LINK = {
+    variants: [
+      // too much like nested array access in so many languages
+      // to have any real relevance
+      {
+        begin: /\[.+?\]\[.*?\]/,
+        relevance: 0
+      },
+      // popular internet URLs
+      {
+        begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
+        relevance: 2
+      },
+      {
+        begin: concat(/\[.+?\]\(/, URL_SCHEME, /:\/\/.*?\)/),
+        relevance: 2
+      },
+      // relative urls
+      {
+        begin: /\[.+?\]\([./?&#].*?\)/,
+        relevance: 1
+      },
+      // whatever else, lower relevance (might not be a link at all)
+      {
+        begin: /\[.+?\]\(.*?\)/,
+        relevance: 0
+      }
+    ],
+    returnBegin: true,
+    contains: [
+      {
+        className: 'string',
+        relevance: 0,
+        begin: '\\[',
+        end: '\\]',
+        excludeBegin: true,
+        returnEnd: true
+      },
+      {
+        className: 'link',
+        relevance: 0,
+        begin: '\\]\\(',
+        end: '\\)',
+        excludeBegin: true,
+        excludeEnd: true
+      },
+      {
+        className: 'symbol',
+        relevance: 0,
+        begin: '\\]\\[',
+        end: '\\]',
+        excludeBegin: true,
+        excludeEnd: true
+      }
+    ]
+  };
+  const BOLD = {
+    className: 'strong',
+    contains: [], // defined later
+    variants: [
+      {
+        begin: /_{2}/,
+        end: /_{2}/
+      },
+      {
+        begin: /\*{2}/,
+        end: /\*{2}/
+      }
+    ]
+  };
+  const ITALIC = {
+    className: 'emphasis',
+    contains: [], // defined later
+    variants: [
+      {
+        begin: /\*(?!\*)/,
+        end: /\*/
+      },
+      {
+        begin: /_(?!_)/,
+        end: /_/,
+        relevance: 0
+      }
+    ]
+  };
+  BOLD.contains.push(ITALIC);
+  ITALIC.contains.push(BOLD);
+
+  let CONTAINABLE = [
+    INLINE_HTML,
+    LINK
+  ];
+
+  BOLD.contains = BOLD.contains.concat(CONTAINABLE);
+  ITALIC.contains = ITALIC.contains.concat(CONTAINABLE);
+
+  CONTAINABLE = CONTAINABLE.concat(BOLD, ITALIC);
+
+  const HEADER = {
+    className: 'section',
+    variants: [
+      {
+        begin: '^#{1,6}',
+        end: '$',
+        contains: CONTAINABLE
+      },
+      {
+        begin: '(?=^.+?\\n[=-]{2,}$)',
+        contains: [
+          {
+            begin: '^[=-]*$'
+          },
+          {
+            begin: '^',
+            end: "\\n",
+            contains: CONTAINABLE
+          }
+        ]
+      }
+    ]
+  };
+
+  const BLOCKQUOTE = {
+    className: 'quote',
+    begin: '^>\\s+',
+    contains: CONTAINABLE,
+    end: '$'
+  };
+
+  return {
+    name: 'Markdown',
+    aliases: [
+      'md',
+      'mkdown',
+      'mkd'
+    ],
+    contains: [
+      HEADER,
+      INLINE_HTML,
+      LIST,
+      BOLD,
+      ITALIC,
+      BLOCKQUOTE,
+      CODE,
+      HORIZONTAL_RULE,
+      LINK,
+      LINK_REFERENCE
+    ]
+  };
+}
+
+module.exports = markdown;

adi-ui/.pnpm-store/v10/files/00/a57a15f33ea119444ef22209df60f2bbbca2f95951bfd4f30205dbb1652df1db595f2f918e6818fbb271cb14ff10d7bbc92a19f063381f1d5f7f94d5521aab

@@ -0,0 +1 @@
+{"version":3,"file":"range.js","sources":["../src/observable/range.ts"],"names":[],"mappings":";;;;;AAAA,kDAA6C"}

adi-ui/.pnpm-store/v10/files/00/a60c4f91a3bd1d6020ef4ff67e26da5a049491b6099cea20c5bb6d955d21452161acd1a7da42a78b4ec12c619758fbc61b41c6dd6a8c02d1277db8386def6b

@@ -0,0 +1,20 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class NoEmitOnErrorsPlugin {
+	apply(compiler) {
+		compiler.hooks.shouldEmit.tap("NoEmitOnErrorsPlugin", compilation => {
+			if (compilation.getStats().hasErrors()) return false;
+		});
+		compiler.hooks.compilation.tap("NoEmitOnErrorsPlugin", compilation => {
+			compilation.hooks.shouldRecord.tap("NoEmitOnErrorsPlugin", () => {
+				if (compilation.getStats().hasErrors()) return false;
+			});
+		});
+	}
+}
+
+module.exports = NoEmitOnErrorsPlugin;

adi-ui/.pnpm-store/v10/files/00/a7e3087857f4bae37649d1a5ab97ff134105707690cb1649cb8f9f449e192c99a65ff0b937fec4e8a5fd8070cad7f1961cf308e7a944c40a29531f71938943

@@ -0,0 +1,178 @@
+'use strict';
+module.exports = function generate__formatLimit(it, $keyword, $ruleType) {
+  var out = ' ';
+  var $lvl = it.level;
+  var $dataLvl = it.dataLevel;
+  var $schema = it.schema[$keyword];
+  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
+  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;
+  var $breakOnError = !it.opts.allErrors;
+  var $errorKeyword;
+  var $data = 'data' + ($dataLvl || '');
+  var $valid = 'valid' + $lvl;
+  out += 'var ' + ($valid) + ' = undefined;';
+  if (it.opts.format === false) {
+    out += ' ' + ($valid) + ' = true; ';
+    return out;
+  }
+  var $schemaFormat = it.schema.format,
+    $isDataFormat = it.opts.$data && $schemaFormat.$data,
+    $closingBraces = '';
+  if ($isDataFormat) {
+    var $schemaValueFormat = it.util.getData($schemaFormat.$data, $dataLvl, it.dataPathArr),
+      $format = 'format' + $lvl,
+      $compare = 'compare' + $lvl;
+    out += ' var ' + ($format) + ' = formats[' + ($schemaValueFormat) + '] , ' + ($compare) + ' = ' + ($format) + ' && ' + ($format) + '.compare;';
+  } else {
+    var $format = it.formats[$schemaFormat];
+    if (!($format && $format.compare)) {
+      out += '  ' + ($valid) + ' = true; ';
+      return out;
+    }
+    var $compare = 'formats' + it.util.getProperty($schemaFormat) + '.compare';
+  }
+  var $isMax = $keyword == 'formatMaximum',
+    $exclusiveKeyword = 'formatExclusive' + ($isMax ? 'Maximum' : 'Minimum'),
+    $schemaExcl = it.schema[$exclusiveKeyword],
+    $isDataExcl = it.opts.$data && $schemaExcl && $schemaExcl.$data,
+    $op = $isMax ? '<' : '>',
+    $result = 'result' + $lvl;
+  var $isData = it.opts.$data && $schema && $schema.$data,
+    $schemaValue;
+  if ($isData) {
+    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';
+    $schemaValue = 'schema' + $lvl;
+  } else {
+    $schemaValue = $schema;
+  }
+  if ($isDataExcl) {
+    var $schemaValueExcl = it.util.getData($schemaExcl.$data, $dataLvl, it.dataPathArr),
+      $exclusive = 'exclusive' + $lvl,
+      $opExpr = 'op' + $lvl,
+      $opStr = '\' + ' + $opExpr + ' + \'';
+    out += ' var schemaExcl' + ($lvl) + ' = ' + ($schemaValueExcl) + '; ';
+    $schemaValueExcl = 'schemaExcl' + $lvl;
+    out += ' if (typeof ' + ($schemaValueExcl) + ' != \'boolean\' && ' + ($schemaValueExcl) + ' !== undefined) { ' + ($valid) + ' = false; ';
+    var $errorKeyword = $exclusiveKeyword;
+    var $$outStack = $$outStack || [];
+    $$outStack.push(out);
+    out = ''; /* istanbul ignore else */
+    if (it.createErrors !== false) {
+      out += ' { keyword: \'' + ($errorKeyword || '_formatExclusiveLimit') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';
+      if (it.opts.messages !== false) {
+        out += ' , message: \'' + ($exclusiveKeyword) + ' should be boolean\' ';
+      }
+      if (it.opts.verbose) {
+        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';
+      }
+      out += ' } ';
+    } else {
+      out += ' {} ';
+    }
+    var __err = out;
+    out = $$outStack.pop();
+    if (!it.compositeRule && $breakOnError) {
+      /* istanbul ignore if */
+      if (it.async) {
+        out += ' throw new ValidationError([' + (__err) + ']); ';
+      } else {
+        out += ' validate.errors = [' + (__err) + ']; return false; ';
+      }
+    } else {
+      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';
+    }
+    out += ' }  ';
+    if ($breakOnError) {
+      $closingBraces += '}';
+      out += ' else { ';
+    }
+    if ($isData) {
+      out += ' if (' + ($schemaValue) + ' === undefined) ' + ($valid) + ' = true; else if (typeof ' + ($schemaValue) + ' != \'string\') ' + ($valid) + ' = false; else { ';
+      $closingBraces += '}';
+    }
+    if ($isDataFormat) {
+      out += ' if (!' + ($compare) + ') ' + ($valid) + ' = true; else { ';
+      $closingBraces += '}';
+    }
+    out += ' var ' + ($result) + ' = ' + ($compare) + '(' + ($data) + ',  ';
+    if ($isData) {
+      out += '' + ($schemaValue);
+    } else {
+      out += '' + (it.util.toQuotedString($schema));
+    }
+    out += ' ); if (' + ($result) + ' === undefined) ' + ($valid) + ' = false; var ' + ($exclusive) + ' = ' + ($schemaValueExcl) + ' === true; if (' + ($valid) + ' === undefined) { ' + ($valid) + ' = ' + ($exclusive) + ' ? ' + ($result) + ' ' + ($op) + ' 0 : ' + ($result) + ' ' + ($op) + '= 0; } if (!' + ($valid) + ') var op' + ($lvl) + ' = ' + ($exclusive) + ' ? \'' + ($op) + '\' : \'' + ($op) + '=\';';
+  } else {
+    var $exclusive = $schemaExcl === true,
+      $opStr = $op;
+    if (!$exclusive) $opStr += '=';
+    var $opExpr = '\'' + $opStr + '\'';
+    if ($isData) {
+      out += ' if (' + ($schemaValue) + ' === undefined) ' + ($valid) + ' = true; else if (typeof ' + ($schemaValue) + ' != \'string\') ' + ($valid) + ' = false; else { ';
+      $closingBraces += '}';
+    }
+    if ($isDataFormat) {
+      out += ' if (!' + ($compare) + ') ' + ($valid) + ' = true; else { ';
+      $closingBraces += '}';
+    }
+    out += ' var ' + ($result) + ' = ' + ($compare) + '(' + ($data) + ',  ';
+    if ($isData) {
+      out += '' + ($schemaValue);
+    } else {
+      out += '' + (it.util.toQuotedString($schema));
+    }
+    out += ' ); if (' + ($result) + ' === undefined) ' + ($valid) + ' = false; if (' + ($valid) + ' === undefined) ' + ($valid) + ' = ' + ($result) + ' ' + ($op);
+    if (!$exclusive) {
+      out += '=';
+    }
+    out += ' 0;';
+  }
+  out += '' + ($closingBraces) + 'if (!' + ($valid) + ') { ';
+  var $errorKeyword = $keyword;
+  var $$outStack = $$outStack || [];
+  $$outStack.push(out);
+  out = ''; /* istanbul ignore else */
+  if (it.createErrors !== false) {
+    out += ' { keyword: \'' + ($errorKeyword || '_formatLimit') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { comparison: ' + ($opExpr) + ', limit:  ';
+    if ($isData) {
+      out += '' + ($schemaValue);
+    } else {
+      out += '' + (it.util.toQuotedString($schema));
+    }
+    out += ' , exclusive: ' + ($exclusive) + ' } ';
+    if (it.opts.messages !== false) {
+      out += ' , message: \'should be ' + ($opStr) + ' "';
+      if ($isData) {
+        out += '\' + ' + ($schemaValue) + ' + \'';
+      } else {
+        out += '' + (it.util.escapeQuotes($schema));
+      }
+      out += '"\' ';
+    }
+    if (it.opts.verbose) {
+      out += ' , schema:  ';
+      if ($isData) {
+        out += 'validate.schema' + ($schemaPath);
+      } else {
+        out += '' + (it.util.toQuotedString($schema));
+      }
+      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';
+    }
+    out += ' } ';
+  } else {
+    out += ' {} ';
+  }
+  var __err = out;
+  out = $$outStack.pop();
+  if (!it.compositeRule && $breakOnError) {
+    /* istanbul ignore if */
+    if (it.async) {
+      out += ' throw new ValidationError([' + (__err) + ']); ';
+    } else {
+      out += ' validate.errors = [' + (__err) + ']; return false; ';
+    }
+  } else {
+    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';
+  }
+  out += '}';
+  return out;
+}

adi-ui/.pnpm-store/v10/files/00/a9aeaf93dcff7335010e076c3259d3422eb40e730a2e25f50df8ebb5d7944d5f961b6f2a9bf6267a1ce8ca3f97058d3235ae5d6f96ffb0461eabfdcd04e97f

@@ -0,0 +1,49 @@
+// tar -x
+import * as fsm from '@isaacs/fs-minipass';
+import fs from 'node:fs';
+import { filesFilter } from './list.js';
+import { makeCommand } from './make-command.js';
+import { Unpack, UnpackSync } from './unpack.js';
+const extractFileSync = (opt) => {
+    const u = new UnpackSync(opt);
+    const file = opt.file;
+    const stat = fs.statSync(file);
+    // This trades a zero-byte read() syscall for a stat
+    // However, it will usually result in less memory allocation
+    const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+    const stream = new fsm.ReadStreamSync(file, {
+        readSize: readSize,
+        size: stat.size,
+    });
+    stream.pipe(u);
+};
+const extractFile = (opt, _) => {
+    const u = new Unpack(opt);
+    const readSize = opt.maxReadSize || 16 * 1024 * 1024;
+    const file = opt.file;
+    const p = new Promise((resolve, reject) => {
+        u.on('error', reject);
+        u.on('close', resolve);
+        // This trades a zero-byte read() syscall for a stat
+        // However, it will usually result in less memory allocation
+        fs.stat(file, (er, stat) => {
+            if (er) {
+                reject(er);
+            }
+            else {
+                const stream = new fsm.ReadStream(file, {
+                    readSize: readSize,
+                    size: stat.size,
+                });
+                stream.on('error', reject);
+                stream.pipe(u);
+            }
+        });
+    });
+    return p;
+};
+export const extract = makeCommand(extractFileSync, extractFile, opt => new UnpackSync(opt), opt => new Unpack(opt), (opt, files) => {
+    if (files?.length)
+        filesFilter(opt, files);
+});
+//# sourceMappingURL=extract.js.map

adi-ui/.pnpm-store/v10/files/00/af795c0c0821c5d5179914127f524638179b45e2fa560dcbebe79257f7e366cc1e83d419ed22da0ab67f36eb85567a0a942ce1e857fce9157026602d240c40

@@ -0,0 +1 @@
+{"version":3,"file":"refCount.js","sourceRoot":"","sources":["../../../../src/internal/operators/refCount.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AA4DhE,MAAM,UAAU,QAAQ;IACtB,OAAO,OAAO,CAAC,UAAC,MAAM,EAAE,UAAU;QAChC,IAAI,UAAU,GAAwB,IAAI,CAAC;QAE1C,MAAc,CAAC,SAAS,EAAE,CAAC;QAE5B,IAAM,UAAU,GAAG,wBAAwB,CAAC,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;YACvF,IAAI,CAAC,MAAM,IAAK,MAAc,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAG,MAAc,CAAC,SAAS,EAAE;gBAChF,UAAU,GAAG,IAAI,CAAC;gBAClB,OAAO;aACR;YA2BD,IAAM,gBAAgB,GAAI,MAAc,CAAC,WAAW,CAAC;YACrD,IAAM,IAAI,GAAG,UAAU,CAAC;YACxB,UAAU,GAAG,IAAI,CAAC;YAElB,IAAI,gBAAgB,IAAI,CAAC,CAAC,IAAI,IAAI,gBAAgB,KAAK,IAAI,CAAC,EAAE;gBAC5D,gBAAgB,CAAC,WAAW,EAAE,CAAC;aAChC;YAED,UAAU,CAAC,WAAW,EAAE,CAAC;QAC3B,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAE7B,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;YACtB,UAAU,GAAI,MAAmC,CAAC,OAAO,EAAE,CAAC;SAC7D;IACH,CAAC,CAAC,CAAC;AACL,CAAC"}

adi-ui/.pnpm-store/v10/files/00/b3c5594bfcaf392beb664e29774278c8b13bcaf317faec624b83e0780dfa2a1e99840fe16cfc3b91af92b860082a7469410392b531feae8ceef2ea87e2b442

@@ -0,0 +1,42 @@
+var Buffer = require('safe-buffer').Buffer
+
+function encryptByte (self, byteParam, decrypt) {
+  var pad
+  var i = -1
+  var len = 8
+  var out = 0
+  var bit, value
+  while (++i < len) {
+    pad = self._cipher.encryptBlock(self._prev)
+    bit = (byteParam & (1 << (7 - i))) ? 0x80 : 0
+    value = pad[0] ^ bit
+    out += ((value & 0x80) >> (i % 8))
+    self._prev = shiftIn(self._prev, decrypt ? bit : value)
+  }
+  return out
+}
+
+function shiftIn (buffer, value) {
+  var len = buffer.length
+  var i = -1
+  var out = Buffer.allocUnsafe(buffer.length)
+  buffer = Buffer.concat([buffer, Buffer.from([value])])
+
+  while (++i < len) {
+    out[i] = buffer[i] << 1 | buffer[i + 1] >> (7)
+  }
+
+  return out
+}
+
+exports.encrypt = function (self, chunk, decrypt) {
+  var len = chunk.length
+  var out = Buffer.allocUnsafe(len)
+  var i = -1
+
+  while (++i < len) {
+    out[i] = encryptByte(self, chunk[i], decrypt)
+  }
+
+  return out
+}

adi-ui/.pnpm-store/v10/files/00/b4b2fa00b5fb4c5e73533bbfac693d9482e5a62e1d1cfb0fe6ae75e2a829553d424a45c515cef412b06ecbc2ee1e3ab58bfce5c5a99898361fdc32a1200ca3

@@ -0,0 +1,132 @@
+if (process.env.OBJECT_IMPL) global.TYPED_ARRAY_SUPPORT = false
+var B = require('../').Buffer
+var test = require('tape')
+
+test('detect utf16 surrogate pairs', function (t) {
+  var text = '\uD83D\uDE38' + '\uD83D\uDCAD' + '\uD83D\uDC4D'
+  var buf = new B(text)
+  t.equal(text, buf.toString())
+  t.end()
+})
+
+test('detect utf16 surrogate pairs over U+20000 until U+10FFFF', function (t) {
+  var text = '\uD842\uDFB7' + '\uD93D\uDCAD' + '\uDBFF\uDFFF'
+  var buf = new B(text)
+  t.equal(text, buf.toString())
+  t.end()
+})
+
+test('replace orphaned utf16 surrogate lead code point', function (t) {
+  var text = '\uD83D\uDE38' + '\uD83D' + '\uD83D\uDC4D'
+  var buf = new B(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0xef, 0xbf, 0xbd, 0xf0, 0x9f, 0x91, 0x8d ]))
+  t.end()
+})
+
+test('replace orphaned utf16 surrogate trail code point', function (t) {
+  var text = '\uD83D\uDE38' + '\uDCAD' + '\uD83D\uDC4D'
+  var buf = new B(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0xef, 0xbf, 0xbd, 0xf0, 0x9f, 0x91, 0x8d ]))
+  t.end()
+})
+
+test('do not write partial utf16 code units', function (t) {
+  var f = new B([0, 0, 0, 0, 0])
+  t.equal(f.length, 5)
+  var size = f.write('あいうえお', 'utf16le')
+  t.equal(size, 4)
+  t.deepEqual(f, new B([0x42, 0x30, 0x44, 0x30, 0x00]))
+  t.end()
+})
+
+test('handle partial utf16 code points when encoding to utf8 the way node does', function (t) {
+  var text = '\uD83D\uDE38' + '\uD83D\uDC4D'
+
+  var buf = new B(8)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0xf0, 0x9f, 0x91, 0x8d ]))
+
+  buf = new B(7)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0x00, 0x00, 0x00 ]))
+
+  buf = new B(6)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0x00, 0x00 ]))
+
+  buf = new B(5)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8, 0x00 ]))
+
+  buf = new B(4)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0xf0, 0x9f, 0x98, 0xb8 ]))
+
+  buf = new B(3)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x00, 0x00, 0x00 ]))
+
+  buf = new B(2)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x00, 0x00 ]))
+
+  buf = new B(1)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x00 ]))
+
+  t.end()
+})
+
+test('handle invalid utf16 code points when encoding to utf8 the way node does', function (t) {
+  var text = 'a' + '\uDE38\uD83D' + 'b'
+
+  var buf = new B(8)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0xef, 0xbf, 0xbd, 0xef, 0xbf, 0xbd, 0x62 ]))
+
+  buf = new B(7)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0xef, 0xbf, 0xbd, 0xef, 0xbf, 0xbd ]))
+
+  buf = new B(6)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0xef, 0xbf, 0xbd, 0x00, 0x00 ]))
+
+  buf = new B(5)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0xef, 0xbf, 0xbd, 0x00 ]))
+
+  buf = new B(4)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0xef, 0xbf, 0xbd ]))
+
+  buf = new B(3)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0x00, 0x00 ]))
+
+  buf = new B(2)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61, 0x00 ]))
+
+  buf = new B(1)
+  buf.fill(0)
+  buf.write(text)
+  t.deepEqual(buf, new B([ 0x61 ]))
+
+  t.end()
+})

adi-ui/.pnpm-store/v10/files/00/b7ad64058d18c6ae7bc89f24d47bbd06464ae6728ceab0fef7d11728d93e4297f36c0c78e5e2f07128a0f5843d2b48ff3d937a93bd2edb86abb835c0f9731b

@@ -0,0 +1,1003 @@
+'use strict';
+
+const generate = require('regjsgen').generate;
+const parse = require('regjsparser').parse;
+const regenerate = require('regenerate');
+const unicodeMatchProperty = require('unicode-match-property-ecmascript');
+const unicodeMatchPropertyValue = require('unicode-match-property-value-ecmascript');
+const iuMappings = require('./data/iu-mappings.js');
+const iBMPMappings = require('./data/i-bmp-mappings.js');
+const iuFoldings = require('./data/iu-foldings.js');
+const ESCAPE_SETS = require('./data/character-class-escape-sets.js');
+const { UNICODE_SET, UNICODE_IV_SET } = require('./data/all-characters.js');
+
+function flatMap(array, callback) {
+	const result = [];
+	array.forEach(item => {
+		const res = callback(item);
+		if (Array.isArray(res)) {
+			result.push.apply(result, res);
+		} else {
+			result.push(res);
+		}
+	});
+	return result;
+}
+
+function regenerateContainsAstral(regenerateData) {
+	const data = regenerateData.data;
+	return data.length >= 1 && data[data.length - 1] >= 0x10000;
+}
+
+// https://tc39.es/ecma262/#prod-SyntaxCharacter
+const SYNTAX_CHARS = /[\\^$.*+?()[\]{}|]/g;
+
+const ASTRAL_SET = regenerate().addRange(0x10000, 0x10FFFF);
+
+const NEWLINE_SET = regenerate().add(
+	// `LineTerminator`s (https://mths.be/es6#sec-line-terminators):
+	0x000A, // Line Feed <LF>
+	0x000D, // Carriage Return <CR>
+	0x2028, // Line Separator <LS>
+	0x2029  // Paragraph Separator <PS>
+);
+
+// Prepare a Regenerate set containing all code points that are supposed to be
+// matched by `/./u`. https://mths.be/es6#sec-atom
+const DOT_SET_UNICODE = UNICODE_SET.clone() // all Unicode code points
+	.remove(NEWLINE_SET);
+
+const getCharacterClassEscapeSet = (character, unicode, ignoreCase, shouldApplySCF) => {
+	if (unicode) {
+		if (ignoreCase) {
+			const result = ESCAPE_SETS.UNICODE_IGNORE_CASE.get(character);
+			if (shouldApplySCF) {
+				return ESCAPE_SETS.UNICODESET_IGNORE_CASE.get(character);
+			} else {
+				return result;
+			}
+		}
+		return ESCAPE_SETS.UNICODE.get(character);
+	}
+	return ESCAPE_SETS.REGULAR.get(character);
+};
+
+const getUnicodeDotSet = (dotAll) => {
+	return dotAll ? UNICODE_SET : DOT_SET_UNICODE;
+};
+
+const getUnicodePropertyValueSet = (property, value) => {
+	const path = value ?
+		`${ property }/${ value }` :
+		`Binary_Property/${ property }`;
+	try {
+		return require(`regenerate-unicode-properties/${ path }.js`);
+	} catch (exception) {
+		throw new Error(
+			`Failed to recognize value \`${ value }\` for property ` +
+			`\`${ property }\`.`
+		);
+	}
+};
+
+const handleLoneUnicodePropertyNameOrValue = (value) => {
+	// It could be a `General_Category` value or a binary property.
+	// Note: `unicodeMatchPropertyValue` throws on invalid values.
+	try {
+		const property = 'General_Category';
+		const category = unicodeMatchPropertyValue(property, value);
+		return getUnicodePropertyValueSet(property, category);
+	} catch (exception) {}
+	// It’s not a `General_Category` value, so check if it’s a property
+	// of strings.
+	try {
+		return getUnicodePropertyValueSet('Property_of_Strings', value);
+	} catch (exception) {}
+	// Lastly, check if it’s a binary property of single code points.
+	// Note: `unicodeMatchProperty` throws on invalid properties.
+	const property = unicodeMatchProperty(value);
+	return getUnicodePropertyValueSet(property);
+};
+
+const getUnicodePropertyEscapeSet = (value, isNegative, isUnicodeSetIgnoreCase) => {
+	const parts = value.split('=');
+	const firstPart = parts[0];
+	let set;
+	if (parts.length == 1) {
+		set = handleLoneUnicodePropertyNameOrValue(firstPart);
+	} else {
+		// The pattern consists of two parts, i.e. `Property=Value`.
+		const property = unicodeMatchProperty(firstPart);
+		const value = unicodeMatchPropertyValue(property, parts[1]);
+		set = getUnicodePropertyValueSet(property, value);
+	}
+	if (isNegative) {
+		if (set.strings) {
+			throw new Error('Cannot negate Unicode property of strings');
+		}
+		return {
+			characters: (isUnicodeSetIgnoreCase ? UNICODE_IV_SET : UNICODE_SET).clone().remove(set.characters),
+			strings: new Set()
+		};
+	}
+	return {
+		characters: set.characters.clone(),
+		strings: set.strings
+			// We need to escape strings like *️⃣ to make sure that they can be safely used in unions.
+			? new Set(set.strings.map(str => str.replace(SYNTAX_CHARS, '\\$&')))
+			: new Set()
+	};
+};
+
+const getUnicodePropertyEscapeCharacterClassData = (property, isNegative, isUnicodeSetIgnoreCase, shouldApplySCF) => {
+	const set = getUnicodePropertyEscapeSet(property, isNegative, isUnicodeSetIgnoreCase);
+	const data = getCharacterClassEmptyData();
+	const singleChars = shouldApplySCF ? regenerate(set.characters.toArray().map(ch => simpleCaseFolding(ch))) : set.characters;
+	const caseEqFlags = configGetCaseEqFlags();
+	if (caseEqFlags) {
+		for (const codepoint of singleChars.toArray()) {
+			const list = getCaseEquivalents(codepoint, caseEqFlags);
+			if (list) {
+				singleChars.add(list);
+			}
+		}
+	}
+	data.singleChars = singleChars;
+	if (set.strings.size > 0) {
+		data.longStrings = set.strings;
+		data.maybeIncludesStrings = true;
+	}
+	return data;
+};
+
+const CASE_EQ_FLAG_NONE = 0b00;
+const CASE_EQ_FLAG_BMP = 0b01;
+const CASE_EQ_FLAG_UNICODE = 0b10;
+
+function configGetCaseEqFlags() {
+	let flags = CASE_EQ_FLAG_NONE;
+	if (config.modifiersData.i === true) {
+		if (config.transform.modifiers) {
+			flags |= CASE_EQ_FLAG_BMP;
+			if (config.flags.unicode || config.flags.unicodeSets) {
+				flags |= CASE_EQ_FLAG_UNICODE;
+			}
+		}
+	} else if (config.modifiersData.i === undefined) {
+		if (config.transform.unicodeFlag && config.flags.ignoreCase) {
+			flags |= CASE_EQ_FLAG_UNICODE;
+		}
+	}
+	return flags;
+}
+
+// Given a range of code points, add any case-equivalent code points in that range
+// to a set.
+regenerate.prototype.iuAddRange = function(min, max, caseEqFlags) {
+	const $this = this;
+	do {
+		const list = getCaseEquivalents(min, caseEqFlags);
+		if (list) {
+			$this.add(list);
+		}
+	} while (++min <= max);
+	return $this;
+};
+regenerate.prototype.iuRemoveRange = function(min, max, caseEqFlags) {
+	const $this = this;
+	do {
+		const list = getCaseEquivalents(min, caseEqFlags);
+		if (list) {
+			$this.remove(list);
+		}
+	} while (++min <= max);
+	return $this;
+};
+
+const update = (item, pattern) => {
+	let tree = parse(pattern, config.useUnicodeFlag ? 'u' : '', {
+		lookbehind: true,
+		namedGroups: true,
+		unicodePropertyEscape: true,
+		unicodeSet: true,
+		modifiers: true,
+	});
+	switch (tree.type) {
+		case 'characterClass':
+		case 'group':
+		case 'value':
+			// No wrapping needed.
+			break;
+		default:
+			// Wrap the pattern in a non-capturing group.
+			tree = wrap(tree, pattern);
+	}
+	Object.assign(item, tree);
+};
+
+const wrap = (tree, pattern) => {
+	// Wrap the pattern in a non-capturing group.
+	return {
+		'type': 'group',
+		'behavior': 'ignore',
+		'body': [tree],
+		'raw': `(?:${ pattern })`
+	};
+};
+
+/**
+ * Given any codepoint ch, returns false or an array of characters,
+ * such that for every c in the array,
+ *   c != ch and Canonicalize(~, c) == Canonicalize(~, ch)
+ * 
+ * where Canonicalize is defined in
+ * https://tc39.es/ecma262/#sec-runtime-semantics-canonicalize-ch
+ * @param {number} codePoint input code point
+ * @param {number} flags bitwise flags composed of CASE_EQ_FLAG_*
+ * @returns false | number[]
+ */
+const getCaseEquivalents = (codePoint, flags) => {
+	if (flags === CASE_EQ_FLAG_NONE) {
+		return false;
+	}
+	let result = ((flags & CASE_EQ_FLAG_UNICODE) ? iuMappings.get(codePoint) : undefined) || [];
+	if (typeof result === "number") result = [result];
+	if (flags & CASE_EQ_FLAG_BMP) {
+		for (const cp of [codePoint].concat(result)) {
+			// Fast path for ASCII characters
+			if (cp >= 0x41 && cp <= 0x5a) {
+				result.push(cp + 0x20);
+			} else if (cp >= 0x61 && cp <= 0x7a) {
+				result.push(cp - 0x20);
+			} else {
+				result = result.concat(iBMPMappings.get(cp) || []);
+			}
+		}
+	}
+	return result.length == 0 ? false : result;
+};
+
+// https://tc39.es/ecma262/#sec-maybesimplecasefolding
+const simpleCaseFolding = (codePoint) => {
+	// Fast path for ASCII characters
+	if (codePoint <= 0x7F) {
+		if (codePoint >= 0x41 && codePoint <= 0x5A) {
+			return codePoint + 0x20;
+		}
+		return codePoint;
+	}
+	return iuFoldings.get(codePoint) || codePoint;
+}
+
+const buildHandler = (action) => {
+	switch (action) {
+		case 'union':
+			return {
+				single: (data, cp) => {
+					data.singleChars.add(cp);
+				},
+				regSet: (data, set2) => {
+					data.singleChars.add(set2);
+				},
+				range: (data, start, end) => {
+					data.singleChars.addRange(start, end);
+				},
+				iuRange: (data, start, end, caseEqFlags) => {
+					data.singleChars.iuAddRange(start, end, caseEqFlags);
+				},
+				nested: (data, nestedData) => {
+					data.singleChars.add(nestedData.singleChars);
+					for (const str of nestedData.longStrings) data.longStrings.add(str);
+					if (nestedData.maybeIncludesStrings) data.maybeIncludesStrings = true;
+				}
+			};
+		case 'union-negative': {
+			const regSet = (data, set2) => {
+				data.singleChars = UNICODE_SET.clone().remove(set2).add(data.singleChars);
+			};
+			return {
+				single: (data, cp) => {
+					const unicode = UNICODE_SET.clone();
+					data.singleChars = data.singleChars.contains(cp) ? unicode : unicode.remove(cp);
+				},
+				regSet: regSet,
+				range: (data, start, end) => {
+					data.singleChars = UNICODE_SET.clone().removeRange(start, end).add(data.singleChars);
+				},
+				iuRange: (data, start, end, caseEqFlags) => {
+					data.singleChars = UNICODE_SET.clone().iuRemoveRange(start, end, caseEqFlags).add(data.singleChars);
+				},
+				nested: (data, nestedData) => {
+					regSet(data, nestedData.singleChars);
+					if (nestedData.maybeIncludesStrings) throw new Error('ASSERTION ERROR');
+				}
+			};
+		}
+		case 'intersection': {
+			const regSet = (data, set2) => {
+				if (data.first) data.singleChars = set2;
+				else data.singleChars.intersection(set2);
+			};
+			return {
+				single: (data, cp) => {
+					data.singleChars = data.first || data.singleChars.contains(cp) ? regenerate(cp) : regenerate();
+					data.longStrings.clear();
+					data.maybeIncludesStrings = false;
+				},
+				regSet: (data, set) => {
+					regSet(data, set);
+					data.longStrings.clear();
+					data.maybeIncludesStrings = false;
+				},
+				range: (data, start, end) => {
+					if (data.first) data.singleChars.addRange(start, end);
+					else data.singleChars.intersection(regenerate().addRange(start, end));
+					data.longStrings.clear();
+					data.maybeIncludesStrings = false;
+				},
+				iuRange: (data, start, end, caseEqFlags) => {
+					if (data.first) data.singleChars.iuAddRange(start, end, caseEqFlags);
+					else data.singleChars.intersection(regenerate().iuAddRange(start, end, caseEqFlags));
+					data.longStrings.clear();
+					data.maybeIncludesStrings = false;
+				},
+				nested: (data, nestedData) => {
+					regSet(data, nestedData.singleChars);
+
+					if (data.first) {
+						data.longStrings = nestedData.longStrings;
+						data.maybeIncludesStrings = nestedData.maybeIncludesStrings;
+					} else {
+						for (const str of data.longStrings) {
+							if (!nestedData.longStrings.has(str)) data.longStrings.delete(str);
+						}
+						if (!nestedData.maybeIncludesStrings) data.maybeIncludesStrings = false;
+					}
+				}
+			};
+		}
+		case 'subtraction': {
+			const regSet = (data, set2) => {
+				if (data.first) data.singleChars.add(set2);
+				else data.singleChars.remove(set2);
+			};
+			return {
+				single: (data, cp) => {
+					if (data.first) data.singleChars.add(cp);
+					else data.singleChars.remove(cp);
+				},
+				regSet: regSet,
+				range: (data, start, end) => {
+					if (data.first) data.singleChars.addRange(start, end);
+					else data.singleChars.removeRange(start, end);
+				},
+				iuRange: (data, start, end, caseEqFlags) => {
+					if (data.first) data.singleChars.iuAddRange(start, end, caseEqFlags);
+					else data.singleChars.iuRemoveRange(start, end, caseEqFlags);
+				},
+				nested: (data, nestedData) => {
+					regSet(data, nestedData.singleChars);
+
+					if (data.first) {
+						data.longStrings = nestedData.longStrings;
+						data.maybeIncludesStrings = nestedData.maybeIncludesStrings;
+					} else {
+						for (const str of data.longStrings) {
+							if (nestedData.longStrings.has(str)) data.longStrings.delete(str);
+						}
+					}
+				}
+			};
+		}
+		// The `default` clause is only here as a safeguard; it should never be
+		// reached. Code coverage tools should ignore it.
+		/* node:coverage ignore next */
+		default:
+			throw new Error(`Unknown set action: ${ characterClassItem.kind }`);
+	}
+};
+
+const getCharacterClassEmptyData = () => ({
+	transformed: config.transform.unicodeFlag,
+	singleChars: regenerate(),
+	longStrings: new Set(),
+	hasEmptyString: false,
+	first: true,
+	maybeIncludesStrings: false
+});
+
+const concatCaseEquivalents = (codePoint, caseEqFlags) => {
+	const caseEquivalents = getCaseEquivalents(codePoint, caseEqFlags);
+	if (caseEquivalents) {
+		return [codePoint, ...caseEquivalents];
+	}
+	return [codePoint];
+};
+
+const computeClassStrings = (classStrings, regenerateOptions, caseEqFlags, shouldApplySCF) => {
+	let data = getCharacterClassEmptyData();
+
+	for (const string of classStrings.strings) {
+		if (string.characters.length === 1) {
+			const codePoint = shouldApplySCF ? simpleCaseFolding(string.characters[0].codePoint) : string.characters[0].codePoint
+			concatCaseEquivalents(codePoint, caseEqFlags).forEach((cp) => {
+				data.singleChars.add(cp);
+			});
+		} else {
+			let stringifiedString = '';
+			if (caseEqFlags) {
+				for (const ch of string.characters) {
+					const codePoint = shouldApplySCF ? simpleCaseFolding(ch.codePoint) : ch.codePoint;
+					const set = regenerate(concatCaseEquivalents(codePoint, caseEqFlags));
+					stringifiedString += set.toString(regenerateOptions);
+				}
+			} else {
+				for (const ch of string.characters) {
+					const codePoint = shouldApplySCF ? simpleCaseFolding(ch.codePoint) : ch.codePoint;
+					if (codePoint !== ch.codePoint) {
+						stringifiedString += regenerate(codePoint).toString(regenerateOptions);
+					} else {
+						stringifiedString += generate(ch);
+					}
+				}
+			}
+
+			data.longStrings.add(stringifiedString);
+			data.maybeIncludesStrings = true;
+		}
+	}
+
+	return data;
+}
+
+const computeCharacterClass = (characterClassItem, regenerateOptions, shouldApplySCF) => {
+	let data = getCharacterClassEmptyData();
+
+	let handlePositive;
+	let handleNegative;
+
+	let caseEqFlags = configGetCaseEqFlags();
+
+	switch (characterClassItem.kind) {
+		case 'union':
+			handlePositive = buildHandler('union');
+			handleNegative = buildHandler('union-negative');
+			break;
+		case 'intersection':
+			handlePositive = buildHandler('intersection');
+			handleNegative = buildHandler('subtraction');
+			if (config.transform.unicodeSetsFlag) data.transformed = true;
+			if (config.isIgnoreCaseMode) {
+				shouldApplySCF = true;
+			}
+			break;
+		case 'subtraction':
+			handlePositive = buildHandler('subtraction');
+			handleNegative = buildHandler('intersection');
+			if (config.transform.unicodeSetsFlag) data.transformed = true;
+			if (config.isIgnoreCaseMode) {
+				shouldApplySCF = true;
+			}
+			break;
+		// The `default` clause is only here as a safeguard; it should never be
+		// reached. Code coverage tools should ignore it.
+		/* node:coverage ignore next */
+		default:
+			throw new Error(`Unknown character class kind: ${ characterClassItem.kind }`);
+	}
+
+	for (const item of characterClassItem.body) {
+		switch (item.type) {
+			case 'value':
+				const codePoint = shouldApplySCF ? simpleCaseFolding(item.codePoint) : item.codePoint;
+				const list = concatCaseEquivalents(codePoint, caseEqFlags);
+				handlePositive.regSet(data, regenerate(list));
+				if (list.length > 1) {
+					data.transformed = true;
+				}
+				break;
+			case 'characterClassRange':
+				const min = item.min.codePoint;
+				const max = item.max.codePoint;
+				if (shouldApplySCF) {
+					let list = [];
+					for (let cp = min; cp <= max; cp++) {
+						list.push(simpleCaseFolding(cp));
+					}
+					handlePositive.regSet(data, regenerate(list));
+				} else {
+					handlePositive.range(data, min, max);
+				}
+				if (caseEqFlags) {
+					// If shouldApplySCF is true, it is still ok to call iuRange because 
+					// the set [min, max] shares the same case equivalents with scf([min, max])
+					handlePositive.iuRange(data, min, max, caseEqFlags);
+					data.transformed = true;
+				}
+				break;
+			case 'characterClassEscape':
+				handlePositive.regSet(data, getCharacterClassEscapeSet(
+					item.value,
+					config.flags.unicode || config.flags.unicodeSets,
+					config.flags.ignoreCase,
+					shouldApplySCF
+				));
+				break;
+			case 'unicodePropertyEscape':
+				const nestedData = getUnicodePropertyEscapeCharacterClassData(
+					item.value,
+					item.negative,
+					config.flags.unicodeSets && config.isIgnoreCaseMode,
+					shouldApplySCF
+				);
+				handlePositive.nested(data, nestedData);
+				data.transformed =
+					data.transformed ||
+					config.transform.unicodePropertyEscapes ||
+					(config.transform.unicodeSetsFlag && (nestedData.maybeIncludesStrings || characterClassItem.kind !== "union" || item.negative));
+				break;
+			case 'characterClass':
+				const handler = item.negative ? handleNegative : handlePositive;
+				const res = computeCharacterClass(item, regenerateOptions, shouldApplySCF);
+				handler.nested(data, res);
+				data.transformed = true;
+				break;
+			case 'classStrings':
+				handlePositive.nested(data, computeClassStrings(item, regenerateOptions, caseEqFlags, shouldApplySCF));
+				data.transformed = true;
+				break;
+			// The `default` clause is only here as a safeguard; it should never be
+			// reached. Code coverage tools should ignore it.
+			/* node:coverage ignore next */
+			default:
+				throw new Error(`Unknown term type: ${ item.type }`);
+		}
+
+		data.first = false;
+	}
+
+	if (characterClassItem.negative && data.maybeIncludesStrings) {
+		throw new SyntaxError('Cannot negate set containing strings');
+	}
+
+	return data;
+}
+
+const processCharacterClass = (
+	characterClassItem,
+	regenerateOptions,
+	computed = computeCharacterClass(characterClassItem, regenerateOptions)
+) => {
+	const negative = characterClassItem.negative;
+	const { singleChars, transformed, longStrings } = computed;
+	if (transformed) {
+		// If single chars already contains some astral character, regenerate (bmpOnly: true) will create valid regex strings
+		const bmpOnly = regenerateContainsAstral(singleChars);
+		const setStr = singleChars.toString(Object.assign({}, regenerateOptions, { bmpOnly: bmpOnly }));
+
+		if (negative) {
+			if (config.useUnicodeFlag) {
+				update(characterClassItem, `[^${setStr[0] === '[' ? setStr.slice(1, -1) : setStr}]`)
+			} else {
+				if (config.flags.unicode || config.flags.unicodeSets) {
+					if (config.flags.ignoreCase) {
+						const astralCharsSet = singleChars.clone().intersection(ASTRAL_SET);
+						// Assumption: singleChars do not contain lone surrogates.
+						// Regex like /[^\ud800]/u is not supported
+						const surrogateOrBMPSetStr = singleChars
+							.clone()
+							.remove(astralCharsSet)
+							.addRange(0xd800, 0xdfff)
+							.toString({ bmpOnly: true });
+						// Don't generate negative lookahead for astral characters
+						// because the case folding is not working anyway as we break
+						// code points into surrogate pairs.
+						const astralNegativeSetStr = ASTRAL_SET
+							.clone()
+							.remove(astralCharsSet)
+							.toString(regenerateOptions);
+						// The transform here does not support lone surrogates.
+						update(
+							characterClassItem,
+							`(?!${surrogateOrBMPSetStr})[^]|${astralNegativeSetStr}`
+						);
+					} else {
+						// Generate negative set directly when case folding is not involved.
+						const negativeSet = UNICODE_SET.clone().remove(singleChars);
+						update(characterClassItem, negativeSet.toString(regenerateOptions));
+					}
+				} else {
+					update(characterClassItem, `(?!${setStr})[^]`);
+				}
+			}
+		} else {
+			const hasEmptyString = longStrings.has('');
+			const pieces = Array.from(longStrings).sort((a, b) => b.length - a.length);
+
+			if (setStr !== '[]' || longStrings.size === 0) {
+				pieces.splice(pieces.length - (hasEmptyString ? 1 : 0), 0, setStr);
+			}
+
+			update(characterClassItem, pieces.join('|'));
+		}
+	}
+	return characterClassItem;
+};
+
+const assertNoUnmatchedReferences = (groups) => {
+	const unmatchedReferencesNames = Object.keys(groups.unmatchedReferences);
+	if (unmatchedReferencesNames.length > 0) {
+		throw new Error(`Unknown group names: ${unmatchedReferencesNames}`);
+	}
+};
+
+const processModifiers = (item, regenerateOptions, groups) => {
+	const enabling = item.modifierFlags.enabling;
+	const disabling = item.modifierFlags.disabling;
+
+	const oldData = Object.assign({}, config.modifiersData);
+
+	for (const flag of enabling) {
+		config.modifiersData[flag] = true;
+	}
+	for (const flag of disabling) {
+		config.modifiersData[flag] = false;
+	}
+
+	if (config.transform.modifiers) {
+		delete item.modifierFlags;
+		item.behavior = 'ignore';
+	}
+
+	item.body = item.body.map(term => {
+		return processTerm(term, regenerateOptions, groups);
+	});
+
+	config.modifiersData = oldData;
+
+	return item;
+}
+
+const processTerm = (item, regenerateOptions, groups) => {
+	switch (item.type) {
+		case 'dot':
+			if (config.transform.unicodeFlag) {
+				update(
+					item,
+					getUnicodeDotSet(config.isDotAllMode).toString(regenerateOptions)
+				);
+			} else if ((config.modifiersData.s != null ? config.modifiersData.s && config.transform.modifiers : config.transform.dotAllFlag)) {
+				// TODO: consider changing this at the regenerate level.
+				update(item, '[^]');
+			}
+			break;
+		case 'characterClass':
+			item = processCharacterClass(item, regenerateOptions);
+			break;
+		case 'unicodePropertyEscape':
+			const data = getUnicodePropertyEscapeCharacterClassData(item.value, item.negative, config.flags.unicodeSets && config.isIgnoreCaseMode);
+			if (data.maybeIncludesStrings) {
+				if (!config.flags.unicodeSets) {
+					throw new Error(
+						'Properties of strings are only supported when using the unicodeSets (v) flag.'
+					);
+				}
+				if (config.transform.unicodeSetsFlag) {
+					data.transformed = true;
+					item = processCharacterClass(item, regenerateOptions, data);
+				}
+			} else if (config.transform.unicodePropertyEscapes || configGetCaseEqFlags()) {
+				update(
+					item,
+					data.singleChars.toString(regenerateOptions)
+				);
+			}
+			break;
+		case 'characterClassEscape':
+			if (config.transform.unicodeFlag) {
+				update(
+					item,
+					getCharacterClassEscapeSet(
+						item.value,
+						/* config.transform.unicodeFlag implies config.flags.unicode */ true,
+						config.flags.ignoreCase
+					).toString(regenerateOptions)
+				);
+			}
+			break;
+		case 'group':
+			if (item.behavior == 'normal') {
+				groups.lastIndex++;
+			}
+			if (item.name) {
+				const name = item.name.value;
+
+				if (groups.namesConflicts[name]) {
+					throw new Error(
+						`Group '${ name }' has already been defined in this context.`
+					);
+				}
+				groups.namesConflicts[name] = true;
+
+				if (config.transform.namedGroups) {
+					delete item.name;
+				}
+
+				const index = groups.lastIndex;
+				if (!groups.names[name]) {
+					groups.names[name] = [];
+				}
+				groups.names[name].push(index);
+
+				if (groups.onNamedGroup) {
+					groups.onNamedGroup.call(null, name, index);
+				}
+
+				if (groups.unmatchedReferences[name]) {
+					delete groups.unmatchedReferences[name];
+				}
+			}
+			if (item.modifierFlags) {
+				return processModifiers(item, regenerateOptions, groups);
+			}
+			/* falls through */
+		case 'quantifier':
+			item.body = item.body.map(term => {
+				return processTerm(term, regenerateOptions, groups);
+			});
+			break;
+		case 'disjunction':
+			const outerNamesConflicts = groups.namesConflicts;
+			item.body = item.body.map(term => {
+				groups.namesConflicts = Object.create(outerNamesConflicts);
+				return processTerm(term, regenerateOptions, groups);
+			});
+			break;
+		case 'alternative':
+			item.body = flatMap(item.body, term => {
+				const res = processTerm(term, regenerateOptions, groups);
+				// Alternatives cannot contain alternatives; flatten them.
+				return res.type === 'alternative' ? res.body : res;
+			});
+			break;
+		case 'value':
+			const codePoint = item.codePoint;
+			const caseEqFlags = configGetCaseEqFlags();
+			const list = concatCaseEquivalents(codePoint, caseEqFlags);
+			if (list.length === 1 && item.kind === "symbol" && codePoint >= 0x20 && codePoint <= 0x7E) {
+				// skip regenerate when it is a printable ASCII symbol
+				break;
+			}
+			const set = regenerate(list);
+			update(item, set.toString(regenerateOptions));
+			break;
+		case 'reference':
+			if (item.name) {
+				const name = item.name.value;
+				const indexes = groups.names[name];
+				if (!indexes) {
+					groups.unmatchedReferences[name] = true;
+				}
+
+				if (config.transform.namedGroups) {
+					if (indexes) {
+						const body = indexes.map(index => ({
+							'type': 'reference',
+							'matchIndex': index,
+							'raw': '\\' + index,
+						}));
+						if (body.length === 1) {
+							return body[0];
+						}
+						return {
+							'type': 'alternative',
+							'body': body,
+							'raw': body.map(term => term.raw).join(''),
+						};
+					}
+
+					// This named reference comes before the group where it’s defined,
+					// so it’s always an empty match.
+					return {
+						'type': 'group',
+						'behavior': 'ignore',
+						'body': [],
+						'raw': '(?:)',
+					};
+				}
+			}
+			break;
+		case 'anchor':
+			if (config.modifiersData.m && config.transform.modifiers) {
+				if (item.kind == 'start') {
+					update(item, `(?:^|(?<=${NEWLINE_SET.toString()}))`);
+				} else if (item.kind == 'end') {
+					update(item, `(?:$|(?=${NEWLINE_SET.toString()}))`);
+				}
+			}
+		case 'empty':
+			// Nothing to do here.
+			break;
+		// The `default` clause is only here as a safeguard; it should never be
+		// reached. Code coverage tools should ignore it.
+		/* node:coverage ignore next */
+		default:
+			throw new Error(`Unknown term type: ${ item.type }`);
+	}
+	return item;
+};
+
+const config = {
+	'flags': {
+		'ignoreCase': false,
+		'unicode': false,
+		'unicodeSets': false,
+		'dotAll': false,
+		'multiline': false,
+	},
+	'transform': {
+		'dotAllFlag': false,
+		'unicodeFlag': false,
+		'unicodeSetsFlag': false,
+		'unicodePropertyEscapes': false,
+		'namedGroups': false,
+		'modifiers': false,
+	},
+	'modifiersData': {
+		'i': undefined,
+		's': undefined,
+		'm': undefined,
+	},
+	get useUnicodeFlag() {
+		return (this.flags.unicode || this.flags.unicodeSets) && !this.transform.unicodeFlag;
+	},
+	get isDotAllMode() {
+		return (this.modifiersData.s !== undefined ? this.modifiersData.s : this.flags.dotAll);
+	},
+	get isIgnoreCaseMode() {
+		return (this.modifiersData.i !== undefined ? this.modifiersData.i : this.flags.ignoreCase);
+	}
+};
+
+const validateOptions = (options) => {
+	if (!options) return;
+
+	for (const key of Object.keys(options)) {
+		const value = options[key];
+		switch (key) {
+			case 'dotAllFlag':
+			case 'unicodeFlag':
+			case 'unicodePropertyEscapes':
+			case 'unicodeSetsFlag':
+			case 'namedGroups':
+				if (value != null && value !== false && value !== 'transform') {
+					throw new Error(`.${key} must be false (default) or 'transform'.`);
+				}
+				break;
+			// todo: remove modifiers: 'parse' in regexpu-core v7
+			case 'modifiers':
+				if (value != null && value !== false && value !== 'parse' && value !== 'transform') {
+					throw new Error(`.${key} must be false (default), 'parse' or 'transform'.`);
+				}
+				break;
+			case 'onNamedGroup':
+			case 'onNewFlags':
+				if (value != null && typeof value !== 'function') {
+					throw new Error(`.${key} must be a function.`);
+				}
+				break;
+			default:
+				throw new Error(`.${key} is not a valid regexpu-core option.`);
+		}
+	}
+};
+
+const hasFlag = (flags, flag) => flags ? flags.includes(flag) : false;
+const transform = (options, name) => options ? options[name] === 'transform' : false;
+
+const rewritePattern = (pattern, flags, options) => {
+	validateOptions(options);
+
+	config.flags.unicode = hasFlag(flags, 'u');
+	config.flags.unicodeSets = hasFlag(flags, 'v');
+	config.flags.ignoreCase = hasFlag(flags, 'i');
+	config.flags.dotAll = hasFlag(flags, 's');
+	config.flags.multiline = hasFlag(flags, 'm');
+
+	config.transform.dotAllFlag = config.flags.dotAll && transform(options, 'dotAllFlag');
+	config.transform.unicodeFlag = (config.flags.unicode || config.flags.unicodeSets) && transform(options, 'unicodeFlag');
+	config.transform.unicodeSetsFlag = config.flags.unicodeSets && transform(options, 'unicodeSetsFlag');
+
+	// unicodeFlag: 'transform' implies unicodePropertyEscapes: 'transform'
+	config.transform.unicodePropertyEscapes = (config.flags.unicode || config.flags.unicodeSets) && (
+		transform(options, 'unicodeFlag') || transform(options, 'unicodePropertyEscapes')
+	);
+	config.transform.namedGroups = transform(options, 'namedGroups');
+	config.transform.modifiers = transform(options, 'modifiers');
+
+	config.modifiersData.i = undefined;
+	config.modifiersData.s = undefined;
+	config.modifiersData.m = undefined;
+
+	const regjsparserFeatures = {
+		// Enable every stable RegExp feature by default
+		'modifiers': true,
+		'unicodePropertyEscape': true,
+		'unicodeSet': true,
+		'namedGroups': true,
+		'lookbehind': true,
+	};
+
+	const regenerateOptions = {
+		'hasUnicodeFlag': config.useUnicodeFlag,
+		'bmpOnly': !config.flags.unicode && !config.flags.unicodeSets
+	};
+
+	const groups = {
+		'onNamedGroup': options && options.onNamedGroup,
+		'lastIndex': 0,
+		'names': Object.create(null), // { [name]: Array<index> }
+		'namesConflicts': Object.create(null), // { [name]: true }
+		'unmatchedReferences': Object.create(null) // { [name]: true }
+	};
+
+	const tree = parse(pattern, flags, regjsparserFeatures);
+
+	if (config.transform.modifiers) {
+		if (/\(\?[a-z]*-[a-z]+:/.test(pattern)) {
+			// the pattern _likely_ contain inline disabled modifiers
+			// we need to traverse to make sure that they are actually modifiers and to collect them
+			const allDisabledModifiers = Object.create(null)
+			const itemStack = [tree];
+			let node;
+			while (node = itemStack.pop(), node != undefined) {
+				if (Array.isArray(node)) {
+					Array.prototype.push.apply(itemStack, node);
+				} else if (typeof node == 'object' && node != null) {
+					for (const key of Object.keys(node)) {
+						const value = node[key];
+						if (key == 'modifierFlags') {
+							for (const flag of value.disabling) {
+								allDisabledModifiers[flag] = true;
+							}
+						} else if (typeof value == 'object' && value != null) {
+							itemStack.push(value);
+						}
+					}
+				}
+			}
+			if (allDisabledModifiers.i) {
+				config.modifiersData.i = config.flags.ignoreCase;
+			}
+			if (allDisabledModifiers.m) {
+				config.modifiersData.m = config.flags.multiline;
+			}
+			if (allDisabledModifiers.s) {
+				config.modifiersData.s = config.flags.dotAll;
+			}
+		}
+	}
+
+	// Note: `processTerm` mutates `tree` and `groups`.
+	processTerm(tree, regenerateOptions, groups);
+	assertNoUnmatchedReferences(groups);
+
+	const onNewFlags = options && options.onNewFlags;
+	if (onNewFlags) {
+		let newFlags = flags.split('').filter((flag) => !config.modifiersData[flag]).join('');
+		if (config.transform.unicodeSetsFlag) {
+			newFlags = newFlags.replace('v', 'u');
+		}
+		if (config.transform.unicodeFlag) {
+			newFlags = newFlags.replace('u', '');
+		}
+		if (config.transform.dotAllFlag) {
+			newFlags = newFlags.replace('s', '');
+		}
+		onNewFlags(newFlags);
+	}
+
+	return generate(tree);
+};
+
+module.exports = rewritePattern;

adi-ui/.pnpm-store/v10/files/00/bbc917d974342d724fa0aaca54b199ffae2c8a392b21aaca308b217bb868fdf231586e6ff902e91addf320dd617f437184cd8ac3f998c08397391620bd3e88

@@ -0,0 +1,58 @@
+'use strict';
+
+// (C) 1995-2013 Jean-loup Gailly and Mark Adler
+// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//   claim that you wrote the original software. If you use this software
+//   in a product, an acknowledgment in the product documentation would be
+//   appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+//   misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+function GZheader() {
+  /* true if compressed data believed to be text */
+  this.text       = 0;
+  /* modification time */
+  this.time       = 0;
+  /* extra flags (not used when writing a gzip file) */
+  this.xflags     = 0;
+  /* operating system */
+  this.os         = 0;
+  /* pointer to extra field or Z_NULL if none */
+  this.extra      = null;
+  /* extra field length (valid if extra != Z_NULL) */
+  this.extra_len  = 0; // Actually, we don't need it in JS,
+                       // but leave for few code modifications
+
+  //
+  // Setup limits is not necessary because in js we should not preallocate memory
+  // for inflate use constant limit in 65536 bytes
+  //
+
+  /* space at extra (only when reading header) */
+  // this.extra_max  = 0;
+  /* pointer to zero-terminated file name or Z_NULL */
+  this.name       = '';
+  /* space at name (only when reading header) */
+  // this.name_max   = 0;
+  /* pointer to zero-terminated comment or Z_NULL */
+  this.comment    = '';
+  /* space at comment (only when reading header) */
+  // this.comm_max   = 0;
+  /* true if there was or will be a header crc */
+  this.hcrc       = 0;
+  /* true when done reading gzip header (not used when writing a gzip file) */
+  this.done       = false;
+}
+
+module.exports = GZheader;

adi-ui/.pnpm-store/v10/files/00/bea42a1269a5104125c2855294ab42bcac4198bb03b69e013b411e0b5d515bb31864ea228b42f1f55b965200fc61fd779834f6167351ddf42995a9ef8ce0fb

@@ -0,0 +1,172 @@
+
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+(function(root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(['exports'], factory);
+    } else if (
+        typeof exports === 'object' &&
+        typeof exports.nodeName !== 'string'
+    ) {
+        // CommonJS
+        factory(exports);
+    } else {
+        // Browser globals
+        factory({});
+    }
+})(this, function(exports) {
+
+
+/**
+ * Language: Slovenian.
+ */
+
+var localeObj = {
+    time: {
+        month: [
+            'Januar', 'Februar', 'Marec', 'April', 'Maj', 'Junij',
+            'Julij', 'Avgust', 'September', 'Oktober', 'November', 'December'
+        ],
+        monthAbbr: [
+            'Jan', 'Feb', 'Mar', 'Apr', 'Maj', 'Jun',
+            'Jul', 'Avg', 'Sep', 'Okt', 'Nov', 'Dec'
+        ],
+        dayOfWeek: [
+            'Nedelja', 'Ponedeljek', 'Torek', 'Sreda', 'Četrtek', 'Petek', 'Sobota'
+        ],
+        dayOfWeekAbbr: [
+            'Ned', 'Pon', 'Tor', 'Sre', 'Čet', 'Pet', 'Sob'
+        ]
+    },
+    legend: {
+        selector: {
+            all: 'Vsi',
+            inverse: 'Obratno'
+        }
+    },
+    toolbox: {
+        brush: {
+            title: {
+                rect: 'Izbor s pravokotnikom',
+                polygon: 'Izbor z lasom',
+                lineX: 'Vodoravni izbor',
+                lineY: 'Navpični izbor',
+                keep: 'Ohrani izbor',
+                clear: 'Počisti izbor'
+            }
+        },
+        dataView: {
+            title: 'Pogled podatkov',
+            lang: ['Pogled podatkov', 'Zapri', 'Osveži']
+        },
+        dataZoom: {
+            title: {
+                zoom: 'Približaj',
+                back: 'Povrni velikost'
+            }
+        },
+        magicType: {
+            title: {
+                line: 'Preklopi na črtni grafikon',
+                bar: 'Preklopi na stolpčni grafikon',
+                stack: 'Naloži',
+                tiled: 'Drug ob drugem'
+            }
+        },
+        restore: {
+            title: 'Povrni'
+        },
+        saveAsImage: {
+            title: 'Shrani kot sliko',
+            lang: ['Z desnim klikom shrani sliko']
+        }
+    },
+    series: {
+        typeNames: {
+            pie: 'Tortni grafikon',
+            bar: 'Stolpčni grafikon',
+            line: 'Črtni grafikon',
+            scatter: 'Raztreseni grafikon',
+            effectScatter: 'Raztreseni grafikon z efektom',
+            radar: 'Radarski grafikon',
+            tree: 'Drevo',
+            treemap: 'Drevesna struktura',
+            boxplot: 'Boxplot grafikon',
+            candlestick: 'Svečni grafikon',
+            k: 'K line grafikon',
+            heatmap: 'Toplotni zemljevid',
+            map: 'Zemljevid',
+            parallel: 'Zemljevid vzporednih koordinat',
+            lines: 'Črtni grafikon',
+            graph: 'Grafikon razmerij',
+            sankey: 'Sankey grafikon',
+            funnel: 'Lijakasti grafikon',
+            gauge: 'Števec',
+            pictorialBar: 'Stolpčni grafikon s podobo',
+            themeRiver: 'Tematski rečni grafikon',
+            sunburst: 'Večnivojski tortni grafikon'
+        }
+    },
+    aria: {
+        general: {
+            withTitle: 'To je grafikon z naslovom "{title}"',
+            withoutTitle: 'To je grafikon'
+        },
+        series: {
+            single: {
+                prefix: '',
+                withName: ' tipa {seriesType} imenovan {seriesName}.',
+                withoutName: ' tipa {seriesType}.'
+            },
+            multiple: {
+                prefix: '. Sestavljen iz {seriesCount} nizov.',
+                withName: ' Niz {seriesId} je tipa {seriesType} z nazivom {seriesName}.',
+                withoutName: ' Niz {seriesId} je tipa {seriesType}.',
+                separator: {
+                    middle: '',
+                    end: ''
+                }
+            }
+        },
+        data: {
+            allData: 'Podatki so naslednji: ',
+            partialData: 'Prvih {displayCnt} elementov je: ',
+            withName: 'podatek za {name} je {value}',
+            withoutName: '{value}',
+            separator: {
+                middle: ', ',
+                end: '. '
+            }
+        }
+    }
+};
+    for (var key in localeObj) {
+        if (localeObj.hasOwnProperty(key)) {
+            exports[key] = localeObj[key];
+        }
+    }
+        
+});

adi-ui/.pnpm-store/v10/files/00/bff2edcbdc8c08931fd8fdae99fcfd2d1ce56550857c476d3f57cc8aa42e6b67cbc5701f50669f17f5f17ef87f260ed4d757796f618fc770b712cd9793a5bf

@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+var _node = _interopRequireDefault(require("./node"));
+var _types = require("./types");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+var Nesting = /*#__PURE__*/function (_Node) {
+  _inheritsLoose(Nesting, _Node);
+  function Nesting(opts) {
+    var _this;
+    _this = _Node.call(this, opts) || this;
+    _this.type = _types.NESTING;
+    _this.value = '&';
+    return _this;
+  }
+  return Nesting;
+}(_node["default"]);
+exports["default"] = Nesting;
+module.exports = exports.default;

adi-ui/.pnpm-store/v10/files/00/c29cd386b9b8ecf213256ce66a8b87fd60c075bf4208fc7ba7aaf35a24311dc954044c7ad1a73c3af679dbcf9b14bf320da6cf3fc728f4ffade75a073b406b

@@ -0,0 +1,105 @@
+var parseKeys = require('parse-asn1')
+var mgf = require('./mgf')
+var xor = require('./xor')
+var BN = require('bn.js')
+var crt = require('browserify-rsa')
+var createHash = require('create-hash')
+var withPublic = require('./withPublic')
+var Buffer = require('safe-buffer').Buffer
+
+module.exports = function privateDecrypt (privateKey, enc, reverse) {
+  var padding
+  if (privateKey.padding) {
+    padding = privateKey.padding
+  } else if (reverse) {
+    padding = 1
+  } else {
+    padding = 4
+  }
+
+  var key = parseKeys(privateKey)
+  var k = key.modulus.byteLength()
+  if (enc.length > k || new BN(enc).cmp(key.modulus) >= 0) {
+    throw new Error('decryption error')
+  }
+  var msg
+  if (reverse) {
+    msg = withPublic(new BN(enc), key)
+  } else {
+    msg = crt(enc, key)
+  }
+  var zBuffer = Buffer.alloc(k - msg.length)
+  msg = Buffer.concat([zBuffer, msg], k)
+  if (padding === 4) {
+    return oaep(key, msg)
+  } else if (padding === 1) {
+    return pkcs1(key, msg, reverse)
+  } else if (padding === 3) {
+    return msg
+  } else {
+    throw new Error('unknown padding')
+  }
+}
+
+function oaep (key, msg) {
+  var k = key.modulus.byteLength()
+  var iHash = createHash('sha1').update(Buffer.alloc(0)).digest()
+  var hLen = iHash.length
+  if (msg[0] !== 0) {
+    throw new Error('decryption error')
+  }
+  var maskedSeed = msg.slice(1, hLen + 1)
+  var maskedDb = msg.slice(hLen + 1)
+  var seed = xor(maskedSeed, mgf(maskedDb, hLen))
+  var db = xor(maskedDb, mgf(seed, k - hLen - 1))
+  if (compare(iHash, db.slice(0, hLen))) {
+    throw new Error('decryption error')
+  }
+  var i = hLen
+  while (db[i] === 0) {
+    i++
+  }
+  if (db[i++] !== 1) {
+    throw new Error('decryption error')
+  }
+  return db.slice(i)
+}
+
+function pkcs1 (key, msg, reverse) {
+  var p1 = msg.slice(0, 2)
+  var i = 2
+  var status = 0
+  while (msg[i++] !== 0) {
+    if (i >= msg.length) {
+      status++
+      break
+    }
+  }
+  var ps = msg.slice(2, i - 1)
+
+  if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !== '0001' && reverse)) {
+    status++
+  }
+  if (ps.length < 8) {
+    status++
+  }
+  if (status) {
+    throw new Error('decryption error')
+  }
+  return msg.slice(i)
+}
+function compare (a, b) {
+  a = Buffer.from(a)
+  b = Buffer.from(b)
+  var dif = 0
+  var len = a.length
+  if (a.length !== b.length) {
+    dif++
+    len = Math.min(a.length, b.length)
+  }
+  var i = -1
+  while (++i < len) {
+    dif += (a[i] ^ b[i])
+  }
+  return dif
+}

adi-ui/.pnpm-store/v10/files/00/c4410ba7929634f56a9906cb6039e8afcd69575957b9af8d80526d2b31abfee31b05385f1f343a53e7c19b5e02d2d654c42672dff414cc3ce628e87a51d1e4

@@ -0,0 +1,87 @@
+'use strict';
+
+var inherits = require('inherits')
+  , EventEmitter = require('events').EventEmitter
+  ;
+
+var debug = function() {};
+if (process.env.NODE_ENV !== 'production') {
+  debug = require('debug')('sockjs-client:buffered-sender');
+}
+
+function BufferedSender(url, sender) {
+  debug(url);
+  EventEmitter.call(this);
+  this.sendBuffer = [];
+  this.sender = sender;
+  this.url = url;
+}
+
+inherits(BufferedSender, EventEmitter);
+
+BufferedSender.prototype.send = function(message) {
+  debug('send', message);
+  this.sendBuffer.push(message);
+  if (!this.sendStop) {
+    this.sendSchedule();
+  }
+};
+
+// For polling transports in a situation when in the message callback,
+// new message is being send. If the sending connection was started
+// before receiving one, it is possible to saturate the network and
+// timeout due to the lack of receiving socket. To avoid that we delay
+// sending messages by some small time, in order to let receiving
+// connection be started beforehand. This is only a halfmeasure and
+// does not fix the big problem, but it does make the tests go more
+// stable on slow networks.
+BufferedSender.prototype.sendScheduleWait = function() {
+  debug('sendScheduleWait');
+  var self = this;
+  var tref;
+  this.sendStop = function() {
+    debug('sendStop');
+    self.sendStop = null;
+    clearTimeout(tref);
+  };
+  tref = setTimeout(function() {
+    debug('timeout');
+    self.sendStop = null;
+    self.sendSchedule();
+  }, 25);
+};
+
+BufferedSender.prototype.sendSchedule = function() {
+  debug('sendSchedule', this.sendBuffer.length);
+  var self = this;
+  if (this.sendBuffer.length > 0) {
+    var payload = '[' + this.sendBuffer.join(',') + ']';
+    this.sendStop = this.sender(this.url, payload, function(err) {
+      self.sendStop = null;
+      if (err) {
+        debug('error', err);
+        self.emit('close', err.code || 1006, 'Sending error: ' + err);
+        self.close();
+      } else {
+        self.sendScheduleWait();
+      }
+    });
+    this.sendBuffer = [];
+  }
+};
+
+BufferedSender.prototype._cleanup = function() {
+  debug('_cleanup');
+  this.removeAllListeners();
+};
+
+BufferedSender.prototype.close = function() {
+  debug('close');
+  this._cleanup();
+  if (this.sendStop) {
+    this.sendStop();
+    this.sendStop = null;
+  }
+};
+
+module.exports = BufferedSender;

adi-ui/.pnpm-store/v10/files/00/c497bf0e46ba69f12b50bb5d7cfa98e64a5d3d0a559919f5ecdc0d4fb1060e75e9bd469f9c2ec29d9c479d9764af82ff04a779baa849feb75a0fb2b6cd81ea

@@ -0,0 +1,138 @@
+# combined-stream
+
+A stream that emits multiple other streams one after another.
+
+**NB** Currently `combined-stream` works with streams version 1 only. There is ongoing effort to switch this library to streams version 2. Any help is welcome. :) Meanwhile you can explore other libraries that provide streams2 support with more or less compatibility with `combined-stream`.
+
+- [combined-stream2](https://www.npmjs.com/package/combined-stream2): A drop-in streams2-compatible replacement for the combined-stream module.
+
+- [multistream](https://www.npmjs.com/package/multistream): A stream that emits multiple other streams one after another.
+
+## Installation
+
+``` bash
+npm install combined-stream
+```
+
+## Usage
+
+Here is a simple example that shows how you can use combined-stream to combine
+two files into one:
+
+``` javascript
+var CombinedStream = require('combined-stream');
+var fs = require('fs');
+
+var combinedStream = CombinedStream.create();
+combinedStream.append(fs.createReadStream('file1.txt'));
+combinedStream.append(fs.createReadStream('file2.txt'));
+
+combinedStream.pipe(fs.createWriteStream('combined.txt'));
+```
+
+While the example above works great, it will pause all source streams until
+they are needed. If you don't want that to happen, you can set `pauseStreams`
+to `false`:
+
+``` javascript
+var CombinedStream = require('combined-stream');
+var fs = require('fs');
+
+var combinedStream = CombinedStream.create({pauseStreams: false});
+combinedStream.append(fs.createReadStream('file1.txt'));
+combinedStream.append(fs.createReadStream('file2.txt'));
+
+combinedStream.pipe(fs.createWriteStream('combined.txt'));
+```
+
+However, what if you don't have all the source streams yet, or you don't want
+to allocate the resources (file descriptors, memory, etc.) for them right away?
+Well, in that case you can simply provide a callback that supplies the stream
+by calling a `next()` function:
+
+``` javascript
+var CombinedStream = require('combined-stream');
+var fs = require('fs');
+
+var combinedStream = CombinedStream.create();
+combinedStream.append(function(next) {
+  next(fs.createReadStream('file1.txt'));
+});
+combinedStream.append(function(next) {
+  next(fs.createReadStream('file2.txt'));
+});
+
+combinedStream.pipe(fs.createWriteStream('combined.txt'));
+```
+
+## API
+
+### CombinedStream.create([options])
+
+Returns a new combined stream object. Available options are:
+
+* `maxDataSize`
+* `pauseStreams`
+
+The effect of those options is described below.
+
+### combinedStream.pauseStreams = `true`
+
+Whether to apply back pressure to the underlaying streams. If set to `false`,
+the underlaying streams will never be paused. If set to `true`, the
+underlaying streams will be paused right after being appended, as well as when
+`delayedStream.pipe()` wants to throttle.
+
+### combinedStream.maxDataSize = `2 * 1024 * 1024`
+
+The maximum amount of bytes (or characters) to buffer for all source streams.
+If this value is exceeded, `combinedStream` emits an `'error'` event.
+
+### combinedStream.dataSize = `0`
+
+The amount of bytes (or characters) currently buffered by `combinedStream`.
+
+### combinedStream.append(stream)
+
+Appends the given `stream` to the combinedStream object. If `pauseStreams` is
+set to `true, this stream will also be paused right away.
+
+`streams` can also be a function that takes one parameter called `next`. `next`
+is a function that must be invoked in order to provide the `next` stream, see
+example above.
+
+Regardless of how the `stream` is appended, combined-stream always attaches an
+`'error'` listener to it, so you don't have to do that manually.
+
+Special case: `stream` can also be a String or Buffer.
+
+### combinedStream.write(data)
+
+You should not call this, `combinedStream` takes care of piping the appended
+streams into itself for you.
+
+### combinedStream.resume()
+
+Causes `combinedStream` to start drain the streams it manages. The function is
+idempotent, and also emits a `'resume'` event each time which usually goes to
+the stream that is currently being drained.
+
+### combinedStream.pause();
+
+If `combinedStream.pauseStreams` is set to `false`, this does nothing.
+Otherwise a `'pause'` event is emitted, this goes to the stream that is
+currently being drained, so you can use it to apply back pressure.
+
+### combinedStream.end();
+
+Sets `combinedStream.writable` to false, emits an `'end'` event, and removes
+all streams from the queue.
+
+### combinedStream.destroy();
+
+Same as `combinedStream.end()`, except it emits a `'close'` event instead of
+`'end'`.
+
+## License
+
+combined-stream is licensed under the MIT license.

adi-ui/.pnpm-store/v10/files/00/caf3b8b7b16cf4ce56453c064d7e7ffc571667ae2b3f0bd67851c7af89185f73322bdfa3082d315937556c528e49d0584c09d4136b5947905041bdf0586e8a

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _rule = require('../rule/');
+
+var _rule2 = _interopRequireDefault(_rule);
+
+var _util = require('../util');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+function type(rule, value, callback, source, options) {
+  var ruleType = rule.type;
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value, ruleType) && !rule.required) {
+      return callback();
+    }
+    _rule2['default'].required(rule, value, source, errors, options, ruleType);
+    if (!(0, _util.isEmptyValue)(value, ruleType)) {
+      _rule2['default'].type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+}
+
+exports['default'] = type;
+module.exports = exports['default'];

adi-ui/.pnpm-store/v10/files/00/cc854e8bd2f416a8d4c5d04b6792202d921d077255db1fcaee8ce9ffcc55ba7994452145972722f54d804d98234991e1eaeb1329665ff32e9a8ad1b8b86e3a

@@ -0,0 +1,14 @@
+import { AsyncAction } from './AsyncAction';
+import { Subscription } from '../Subscription';
+import { QueueScheduler } from './QueueScheduler';
+import { SchedulerAction } from '../types';
+import { TimerHandle } from './timerHandle';
+export declare class QueueAction<T> extends AsyncAction<T> {
+    protected scheduler: QueueScheduler;
+    protected work: (this: SchedulerAction<T>, state?: T) => void;
+    constructor(scheduler: QueueScheduler, work: (this: SchedulerAction<T>, state?: T) => void);
+    schedule(state?: T, delay?: number): Subscription;
+    execute(state: T, delay: number): any;
+    protected requestAsyncId(scheduler: QueueScheduler, id?: TimerHandle, delay?: number): TimerHandle;
+}
+//# sourceMappingURL=QueueAction.d.ts.map

adi-ui/.pnpm-store/v10/files/00/d39113a88767482f44335c08b8c6b04c87db5ae4a6e1f6c419ea85c2bfad9b165409667b16d696761f487f80d6b94f45ca5e906d3ad3a0405bbb77be8e96f4

@@ -0,0 +1,24 @@
+'use strict';
+require('../modules/web.atob');
+require('../modules/web.btoa');
+require('../modules/web.dom-collections.for-each');
+require('../modules/web.dom-collections.iterator');
+require('../modules/web.dom-exception.constructor');
+require('../modules/web.dom-exception.stack');
+require('../modules/web.dom-exception.to-string-tag');
+require('../modules/web.immediate');
+require('../modules/web.queue-microtask');
+require('../modules/web.self');
+require('../modules/web.structured-clone');
+require('../modules/web.timers');
+require('../modules/web.url');
+require('../modules/web.url.can-parse');
+require('../modules/web.url.parse');
+require('../modules/web.url.to-json');
+require('../modules/web.url-search-params');
+require('../modules/web.url-search-params.delete');
+require('../modules/web.url-search-params.has');
+require('../modules/web.url-search-params.size');
+var path = require('../internals/path');
+
+module.exports = path;